rage-iodine 1.8.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5b5db0d766696d96ae2730a5d954229249dbd982bceba8fb63f184a1da62beb
-  data.tar.gz: 397f34465e987d8f63c253f61ee7e3efd098aa94af63a55eeff81c5c13f5b088
+  metadata.gz: 4221fdb6705dce60cb5e71da2644f639200571f690930fb9c428e29c4ae20032
+  data.tar.gz: c01222eb2a55634b414c456d46319e5d2072a2ed89b258e709ea1d236cf490b9
 SHA512:
-  metadata.gz: 00a9d42202213c7c34292b5d70074d17300736004a5d14df21bf9f1f9b933d3172335e07dbb5617f38c278a1f5073333114622dacd69870f258c65181f638cd4
-  data.tar.gz: bc5d84cf74cd4ee5078452fbd01ac67de8c0d2b7026d71af53136d47e862634fbf25d4910cb7e79280b77dab96bd91e76d92e1de41593e9ed2c11e0d0a2b27fe
+  metadata.gz: ad43ae3016c28c794926b71fd62b4f48c1362c7865f8c0118b8b5548ded1885b28c198a9d93f87a387873b4451b9f7310b545ba079cc26708521dc8c47497f7e
+  data.tar.gz: 0067566c6d7495bc2cc4652f49278d1eaa22f5afd9764cb84b654c44fd2483f7f14ccdcddd656b4ec529ad43c4d285ba8452976b075551c9683651ace0704a5a

data/ext/iodine/http.c

@@ -19,6 +19,7 @@ Feel free to copy, use and enjoy according to the license provided.
 #include <unistd.h>
 
 #include <pthread.h>
+#include <ruby/io.h>
 
 #ifndef HAVE_TM_TM_ZONE
 #if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) ||     \
@@ -61,6 +62,13 @@ fio_tls_alpn_add(void *tls, const char *protocol_name,
 #pragma weak fio_tls_alpn_add
 #endif
 
+static VALUE cTempfile;
+static VALUE tempfile_args;
+static VALUE cUploadedFile;
+static ID create_id;
+static ID path_id;
+static rb_encoding *IodineBinaryEncoding;
+
 /* *****************************************************************************
 Small Helpers
 ***************************************************************************** */
@@ -1797,105 +1805,262 @@ typedef struct {
   size_t pos;
   size_t partial_offset;
   size_t partial_length;
-  FIOBJ partial_name;
+  VALUE partial_name;
+  int partial_fd;
+  VALUE partial_tempfile;
+  VALUE params;
 } http_fio_mime_s;
 
 #define http_mime_parser2fio(parser) ((http_fio_mime_s *)(parser))
 
+/** Parse a parameter key and add it to the `params` hash. Check `parse_nested_query_internal` for reference. */
+static void add_to_params(VALUE params, char *key, size_t key_len, VALUE value) {
+  char *pos = NULL;
+  if (key_len > 1) {
+    pos = memchr(key + 1, '[', key_len - 1);
+  }
+
+  if (!pos) {
+    VALUE k = ID2SYM(rb_intern2(key, key_len));
+    rb_hash_aset(params, k, value);
+  } else {
+    VALUE arr = Qnil, hsh = Qnil, hsh_key = Qnil;
+    VALUE k = ID2SYM(rb_intern2(key, pos - key));
+    char *k_pos, *end = key + key_len;
+    uint8_t depth = 0;
+
+    while (pos < end) {
+      if (depth++ == PARAMS_MAX_DEPTH) {
+        rb_raise(rb_eRuntimeError, "Params too deep");
+      }
+
+      if (*pos == '[' && *(pos + 1) == ']') { // array
+        if (arr != Qnil) {
+          VALUE tmp = rb_ary_new();
+          rb_ary_push(arr, tmp);
+          arr = tmp;
+        } else if (hsh != Qnil) {
+          arr = rb_hash_aref(hsh, hsh_key);
+          if (arr == Qnil) {
+            arr = rb_ary_new();
+            rb_hash_aset(hsh, hsh_key, arr);
+          } else {
+            Check_Type(arr, T_ARRAY);
+          }
+          hsh = hsh_key = Qnil;
+        } else {
+          VALUE tmp = rb_hash_aref(params, k);
+          if (tmp != Qnil) {
+            Check_Type(tmp, T_ARRAY);
+            arr = tmp;
+          } else {
+            arr = rb_ary_new();
+            rb_hash_aset(params, k, arr);
+          }
+        }
+
+        pos += 2;
+
+      } else if (*pos == '[' && *(pos + 1) != ']') { // hash
+        if (pos + 2 < end) {
+          k_pos = memchr(pos + 2, ']', end - pos - 2);
+        } else {
+          k_pos = NULL;
+        }
+
+        if (!k_pos) {
+          rb_raise(rb_eRuntimeError, "Bad params");
+        }
+
+        VALUE prev_hsh_key = hsh_key;
+        hsh_key = ID2SYM(rb_intern2(pos + 1, k_pos - pos - 1));
+
+        if (hsh != Qnil) {
+          VALUE existing = rb_hash_aref(hsh, prev_hsh_key);
+          if (existing != Qnil) {
+            Check_Type(existing, T_HASH);
+            hsh = existing;
+          } else {
+            VALUE tmp = rb_hash_new();
+            rb_hash_aset(hsh, prev_hsh_key, tmp);
+            hsh = tmp;
+          }
+        } else if (arr != Qnil) {
+          VALUE nested_val = Qnil;
+          if (RARRAY_LEN(arr) != 0) {
+            VALUE tmp = rb_ary_entry(arr, -1);
+            Check_Type(tmp, T_HASH);
+            nested_val = rb_hash_aref(tmp, hsh_key);
+          }
+
+          if (RB_TYPE_P(nested_val, T_HASH)) {
+            char *n_pos_start = k_pos + 1, *n_pos_end = k_pos + 1;
+
+            while (nested_val != Qnil && *n_pos_start == '[' && *(n_pos_start + 1) != ']' && *n_pos_end != '&' && *n_pos_end != '=' && n_pos_end < end) {
+              n_pos_end++;
+
+              if (*n_pos_end == ']') {
+                VALUE nested_key = ID2SYM(rb_intern2(n_pos_start + 1, n_pos_end - n_pos_start - 1));
+                Check_Type(nested_val, T_HASH);
+                nested_val = rb_hash_aref(nested_val, nested_key);
+                n_pos_start = ++n_pos_end;
+              }
+            }
+          }
+
+          if (RARRAY_LEN(arr) == 0 || nested_val != Qnil) {
+            hsh = rb_hash_new();
+            rb_ary_push(arr, hsh);
+          } else {
+            hsh = rb_ary_entry(arr, -1);
+            if (hsh != Qnil) {
+              Check_Type(hsh, T_HASH);
+            }
+          }
+
+          arr = Qnil;
+        } else {
+          VALUE tmp = rb_hash_aref(params, k);
+          if (tmp != Qnil) {
+            Check_Type(tmp, T_HASH);
+            hsh = tmp;
+          } else {
+            hsh = rb_hash_new();
+            rb_hash_aset(params, k, hsh);
+          }
+        }
+
+        pos = k_pos + 1;
+
+      } else {
+        pos++;
+      }
+    }
+
+    if (arr != Qnil) {
+      rb_ary_push(arr, value);
+    } else {
+      rb_hash_aset(hsh, hsh_key, value);
+    }
+  }
+}
+
+static inline void cleanup_temp_file(void *r_path) {
+  char *path = StringValueCStr(r_path);
+  IodineStore.remove((VALUE)r_path);
+  unlink(path);
+}
+
+static VALUE create_temp_file(http_mime_parser_s *parser, char **path) {
+  VALUE tempfile = rb_funcallv_kw(cTempfile, create_id, 1, &tempfile_args, RB_PASS_KEYWORDS);
+
+  VALUE r_path = rb_funcall2(tempfile, path_id, 0, NULL);
+  IodineStore.add(r_path);
+  *path = StringValueCStr(r_path);
+
+  http_s *h = http_mime_parser2fio(parser)->h;
+  http_fio_protocol_s *p = (http_fio_protocol_s *)h->private_data.flag;
+  fio_uuid_link(p->uuid, (void *)r_path, cleanup_temp_file); // schedule file deletion
+  
+  return tempfile;
+}
+
+static VALUE build_file_value(VALUE file, char *filename, size_t filename_len, char *mimetype, size_t mimetype_len) {
+  VALUE args[3] = { file, rb_enc_str_new(filename, filename_len, IodineBinaryEncoding), rb_enc_str_new(mimetype, mimetype_len, IodineBinaryEncoding) };
+  VALUE uploaded_file = rb_class_new_instance(3, args, cUploadedFile);
+
+  return uploaded_file;
+}
+
 /** Called when all the data is available at once. */
 static void http_mime_parser_on_data(http_mime_parser_s *parser, void *name,
                                      size_t name_len, void *filename,
                                      size_t filename_len, void *mimetype,
                                      size_t mimetype_len, void *value,
                                      size_t value_len) {
+  // for regular values - just add them to params
   if (!filename_len) {
-    http_add2hash(http_mime_parser2fio(parser)->h->params, name, name_len,
-                  value, value_len, 0);
+    VALUE r_value = rb_enc_str_new(value, value_len, IodineBinaryEncoding);
+    add_to_params(http_mime_parser2fio(parser)->params, name, name_len, r_value);
     return;
   }
-  FIOBJ n = fiobj_str_new(name, name_len);
-  fiobj_str_write(n, "[data]", 6);
-  fio_str_info_s tmp = fiobj_obj2cstr(n);
-  http_add2hash(http_mime_parser2fio(parser)->h->params, tmp.data, tmp.len,
-                value, value_len, 0);
-  fiobj_str_resize(n, name_len);
-  fiobj_str_write(n, "[name]", 6);
-  tmp = fiobj_obj2cstr(n);
-  http_add2hash(http_mime_parser2fio(parser)->h->params, tmp.data, tmp.len,
-                filename, filename_len, 0);
-  if (mimetype_len) {
-    fiobj_str_resize(n, name_len);
-    fiobj_str_write(n, "[type]", 6);
-    tmp = fiobj_obj2cstr(n);
-    http_add2hash(http_mime_parser2fio(parser)->h->params, tmp.data, tmp.len,
-                  mimetype, mimetype_len, 0);
-  }
-  fiobj_free(n);
+
+  // write file data into a temporary file
+  char* path;
+  VALUE r_tempfile = create_temp_file(parser, &path);
+
+  int file = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0777);
+  write(file, value, value_len);
+  close(file);
+
+  VALUE r_value = build_file_value(r_tempfile, filename, filename_len, mimetype, mimetype_len);
+  add_to_params(http_mime_parser2fio(parser)->params, name, name_len, r_value);
 }
 
 /** Called when the data didn't fit in the buffer. Data will be streamed. */
 static void http_mime_parser_on_partial_start(
     http_mime_parser_s *parser, void *name, size_t name_len, void *filename,
     size_t filename_len, void *mimetype, size_t mimetype_len) {
-  http_mime_parser2fio(parser)->partial_length = 0;
-  http_mime_parser2fio(parser)->partial_offset = 0;
-  http_mime_parser2fio(parser)->partial_name = fiobj_str_new(name, name_len);
+
+  // store the parameter name
+  http_mime_parser2fio(parser)->partial_name = rb_str_new(name, name_len);
 
   if (!filename)
     return;
 
-  fiobj_str_write(http_mime_parser2fio(parser)->partial_name, "[type]", 6);
-  fio_str_info_s tmp =
-      fiobj_obj2cstr(http_mime_parser2fio(parser)->partial_name);
-  http_add2hash(http_mime_parser2fio(parser)->h->params, tmp.data, tmp.len,
-                mimetype, mimetype_len, 0);
+  // create and store the temporary file for the file data
+  char* path;
+  VALUE r_tempfile = create_temp_file(parser, &path);
 
-  fiobj_str_resize(http_mime_parser2fio(parser)->partial_name, name_len);
-  fiobj_str_write(http_mime_parser2fio(parser)->partial_name, "[name]", 6);
-  tmp = fiobj_obj2cstr(http_mime_parser2fio(parser)->partial_name);
-  http_add2hash(http_mime_parser2fio(parser)->h->params, tmp.data, tmp.len,
-                filename, filename_len, 0);
-
-  fiobj_str_resize(http_mime_parser2fio(parser)->partial_name, name_len);
-  fiobj_str_write(http_mime_parser2fio(parser)->partial_name, "[data]", 6);
+  http_mime_parser2fio(parser)->partial_fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0777);
+  
+  VALUE r_value = build_file_value(r_tempfile, filename, filename_len, mimetype, mimetype_len);
+  http_mime_parser2fio(parser)->partial_tempfile = r_value;
 }
 
 /** Called when partial data is available. */
 static void http_mime_parser_on_partial_data(http_mime_parser_s *parser,
                                              void *value, size_t value_len) {
-  if (!http_mime_parser2fio(parser)->partial_offset)
-    http_mime_parser2fio(parser)->partial_offset =
-        http_mime_parser2fio(parser)->pos +
-        ((uintptr_t)value -
-         (uintptr_t)http_mime_parser2fio(parser)->buffer.data);
-  http_mime_parser2fio(parser)->partial_length += value_len;
-  (void)value;
+
+  http_fio_mime_s *fio_parser = http_mime_parser2fio(parser);
+
+  // if this is a file - write into it rightaway
+  if (fio_parser->partial_fd) {
+    write(fio_parser->partial_fd, value, value_len);
+    return;
+  }
+
+  // if that's just a large piece of data - store the offset and length values
+  if (!fio_parser->partial_offset) {
+    fio_parser->partial_offset = fio_parser->pos + ((uintptr_t)value - (uintptr_t)fio_parser->buffer.data);
+  }
+  fio_parser->partial_length += value_len;
 }
 
 /** Called when the partial data is complete. */
 static void http_mime_parser_on_partial_end(http_mime_parser_s *parser) {
+  http_fio_mime_s *fio_parser = http_mime_parser2fio(parser);
+
+  // for a file - add to params and close the fd
+  if (fio_parser->partial_fd) {
+    add_to_params(fio_parser->params, RSTRING_PTR(fio_parser->partial_name), RSTRING_LEN(fio_parser->partial_name), fio_parser->partial_tempfile);
+    close(fio_parser->partial_fd);
+
+    fio_parser->partial_name = Qnil;
+    fio_parser->partial_tempfile = Qnil;
+    fio_parser->partial_fd = 0;
 
-  fio_str_info_s tmp =
-      fiobj_obj2cstr(http_mime_parser2fio(parser)->partial_name);
-  FIOBJ o = FIOBJ_INVALID;
-  if (!http_mime_parser2fio(parser)->partial_length)
     return;
-  if (http_mime_parser2fio(parser)->partial_length < 42) {
-    /* short data gets a new object */
-    o = fiobj_str_new(http_mime_parser2fio(parser)->buffer.data +
-                          http_mime_parser2fio(parser)->partial_offset,
-                      http_mime_parser2fio(parser)->partial_length);
-  } else {
-    /* longer data gets a reference object (memory collision concerns) */
-    o = fiobj_data_slice(http_mime_parser2fio(parser)->h->body,
-                         http_mime_parser2fio(parser)->partial_offset,
-                         http_mime_parser2fio(parser)->partial_length);
   }
-  http_add2hash2(http_mime_parser2fio(parser)->h->params, tmp.data, tmp.len, o,
-                 0);
-  fiobj_free(http_mime_parser2fio(parser)->partial_name);
-  http_mime_parser2fio(parser)->partial_name = FIOBJ_INVALID;
-  http_mime_parser2fio(parser)->partial_offset = 0;
+
+  FIOBJ slice = fiobj_data_slice(fio_parser->h->body, fio_parser->partial_offset, fio_parser->partial_length);
+  fio_str_info_s s_slice = fiobj_obj2cstr(slice);
+  VALUE r_value = rb_enc_str_new(s_slice.data, s_slice.len, IodineBinaryEncoding);
+  add_to_params(fio_parser->params, RSTRING_PTR(fio_parser->partial_name), RSTRING_LEN(fio_parser->partial_name), r_value);
+
+  fio_parser->partial_name = Qnil;
+  fio_parser->partial_length = 0;
+  fio_parser->partial_offset = 0;
 }
 
 /**
@@ -1911,65 +2076,29 @@ static inline size_t http_mime_decode_url(char *dest, const char *encoded,
 }
 
 /**
- * Attempts to decode the request's body.
- *
- * Supported Types include:
- * * application/x-www-form-urlencoded
- * * application/json
- * * multipart/form-data
+ * Attempts to decode a multipart/form-data encoded body.
  */
-int http_parse_body(http_s *h) {
-  static uint64_t content_type_hash;
-  if (!h->body)
-    return -1;
-  if (!content_type_hash)
-    content_type_hash = fiobj_hash_string("content-type", 12);
-  FIOBJ ct = fiobj_hash_get2(h->headers, content_type_hash);
-  fio_str_info_s content_type = fiobj_obj2cstr(ct);
-  if (content_type.len < 16)
-    return -1;
-  if (content_type.len >= 33 &&
-      !strncasecmp("application/x-www-form-urlencoded", content_type.data,
-                   33)) {
-    if (!h->params)
-      h->params = fiobj_hash_new();
-    FIOBJ tmp = h->query;
-    h->query = h->body;
-    http_parse_query(h);
-    h->query = tmp;
-    return 0;
-  }
-  if (content_type.len >= 16 &&
-      !strncasecmp("application/json", content_type.data, 16)) {
-    content_type = fiobj_obj2cstr(h->body);
-    if (h->params)
-      return -1;
-    if (fiobj_json2obj(&h->params, content_type.data, content_type.len) == 0)
-      return -1;
-    if (FIOBJ_TYPE_IS(h->params, FIOBJ_T_HASH))
-      return 0;
-    FIOBJ tmp = h->params;
-    FIOBJ key = fiobj_str_new("JSON", 4);
-    h->params = fiobj_hash_new2(4);
-    fiobj_hash_set(h->params, key, tmp);
-    fiobj_free(key);
-    return 0;
+VALUE http_parse_multipart(http_s *h, char *content_type, size_t content_type_len) {
+  static uint8_t http_initialized;
+  if (!http_initialized) {
+    http_initialized = 1;
+    http_init();
   }
 
-  http_fio_mime_s p = {.h = h};
-  if (http_mime_parser_init(&p.p, content_type.data, content_type.len))
-    return -1;
-  if (!h->params)
-    h->params = fiobj_hash_new();
+  VALUE params = rb_hash_new();
+  http_fio_mime_s p = {.h = h, .params = params};
+  if (http_mime_parser_init(&p.p, content_type, content_type_len))
+    rb_raise(rb_eRuntimeError, "Malformed multipart request");
 
   do {
     size_t cons = http_mime_parse(&p.p, p.buffer.data, p.buffer.len);
     p.pos += cons;
-    p.buffer = fiobj_data_pread(h->body, p.pos, 4096);
+    p.buffer = fiobj_data_pread(h->body, p.pos, 262144);
   } while (p.buffer.data && !p.p.done && !p.p.error);
-  fiobj_free(p.partial_name);
-  p.partial_name = FIOBJ_INVALID;
-  return 0;
+  
+  p.params = Qnil;
+
+  return params;
 }
 
 /* *****************************************************************************
@@ -2489,6 +2618,24 @@ ssize_t http_decode_path_unsafe(char *dest, const char *url_data) {
   return pos - dest;
 }
 
+// init the http module to enable multipart/form-data parsing;
+// should be called lazily as it references `Rage`
+void http_init(void) {
+  cTempfile = rb_const_get(rb_cObject, rb_intern("Tempfile"));
+
+  VALUE cRage = rb_const_get(rb_cObject, rb_intern("Rage"));
+  cUploadedFile = rb_const_get(cRage, rb_intern("UploadedFile"));
+  
+  tempfile_args = rb_hash_new();
+  rb_hash_aset(tempfile_args, ID2SYM(rb_intern("binmode")), Qtrue);
+  rb_global_variable(&tempfile_args);
+
+  create_id = rb_intern("create");
+  path_id = rb_intern("path");
+
+  IodineBinaryEncoding = rb_enc_find("binary");
+}
+
 /* *****************************************************************************
 Lookup Tables / functions
 ***************************************************************************** */

data/ext/iodine/http.h

@@ -7,6 +7,8 @@ Feel free to copy, use and enjoy according to the license provided.
 */
 #define H_HTTP_H
 
+#include "ruby.h"
+
 #include <fio.h>
 
 #include <fiobj.h>
@@ -58,6 +60,10 @@ Compile Time Settings
 #define FIO_HTTP_EXACT_LOGGING 0
 #endif
 
+#ifndef PARAMS_MAX_DEPTH
+#define PARAMS_MAX_DEPTH 5
+#endif
+
 /** the `http_listen settings, see details in the struct definition. */
 typedef struct http_settings_s http_settings_s;
 
@@ -772,25 +778,9 @@ HTTP GET and POST parsing helpers
 ***************************************************************************** */
 
 /**
- * Attempts to decode the request's body.
- *
- * Supported Types include:
- * * application/x-www-form-urlencoded
- * * application/json
- * * multipart/form-data
- *
- * This should be called before `http_parse_query`, in order to support JSON
- * data.
- *
- * If the JSON data isn't an object, it will be saved under the key "JSON" in
- * the `params` hash.
- *
- * If the `multipart/form-data` type contains JSON files, they will NOT be
- * parsed (they will behave like any other file, with `data`, `type` and
- * `filename` keys assigned). This allows non-object JSON data (such as array)
- * to be handled by the app.
+ * Attempts to decode a multipart/form-data encoded body.
  */
-int http_parse_body(http_s *h);
+VALUE http_parse_multipart(http_s *h, char *content_type, size_t content_type_len);
 
 /**
  * Parses the query part of an HTTP request/response. Uses `http_add2hash`.
@@ -1007,6 +997,10 @@ typedef fio_url_s http_url_s
  */
 #define http_url_parse(url, len) fio_url_parse((url), (len))
 
+// init the http module to enable multipart/form-data parsing;
+// should be called lazily as it references `Rage`
+void http_init(void);
+
 #if DEBUG
 void http_tests(void);
 #endif

data/ext/iodine/iodine_helpers.c

@@ -209,6 +209,253 @@ static VALUE iodine_rfc2109(VALUE self, VALUE rtm) {
   (void)self;
 }
 
+/**
+Convert query string into a Ruby object in (almost always) one pass with no recursion.
+
+
+        Iodine::Rack::Utils.parse_nested_query("a=1&b[]=2&c[d]=3") # => { "a" => "1", "b" => ["2"], "c" => { "d" => "3" } }
+
+
+
+        query = "a=1&b[]=2&c[d]=3"
+        Benchmark.ips do |x|
+          x.report("Iodine") {
+            Iodine::Rack::Utils.parse_nested_query(query)
+          }
+
+          x.report("Rack") {
+            Rack::Utils.parse_nested_query(query)
+          }
+
+          x.compare!
+        end
+
+
+        Calculating -------------------------------------
+              Iodine      1.088M (~ 1.1%) i/s -      5.526M in   5.077759s
+                Rack     64.258k (~ 1.0%) i/s -    321.657k in   5.006187s
+
+        Comparison:
+                      Iodine:  1088431.2 i/s
+                        Rack:    64257.9 i/s - 16.94x  slower
+
+*/
+static VALUE parse_nested_query_internal(char *str, size_t len) {
+  uint8_t should_decode = 0;
+  VALUE params = rb_hash_new();
+
+  char *pos = str, *k_pos = str, *v_pos = str;
+  const char *end = str + len;
+
+  while (pos < end) {
+    k_pos++;
+
+    if (*k_pos == '=') { // plain param
+      v_pos = k_pos + 1;
+      while (*v_pos != '&' && v_pos < end) {
+        if (*v_pos == '%' || *v_pos == '+') {
+          should_decode = 1;
+        }
+        v_pos++;
+      }
+
+      VALUE k = ID2SYM(rb_intern2(pos, k_pos - pos)), v = rb_str_new(k_pos + 1, v_pos - k_pos - 1);
+      if (should_decode) {
+        rb_hash_aset(params, k, url_decode_inplace(Qnil, v));
+        should_decode = 0;
+      } else {
+        rb_hash_aset(params, k, v);
+      }
+      pos = k_pos = v_pos + 1;
+
+    } else if (*k_pos == '[') { // things are about to get rough now
+      VALUE arr = Qnil, hsh = Qnil, hsh_key = Qnil;
+      VALUE k = ID2SYM(rb_intern2(pos, k_pos - pos)), v;
+      pos = k_pos;
+      uint8_t depth = 0;
+
+      while (*pos != '=' && pos < end) {
+        if (depth++ == PARAMS_MAX_DEPTH) {
+          rb_raise(rb_eRuntimeError, "Params too deep");
+        }
+
+        if (*pos == '[' && *(pos + 1) == ']') { // array
+          if (arr != Qnil) {
+            VALUE tmp = rb_ary_new();
+            rb_ary_push(arr, tmp);
+            arr = tmp;
+          } else if (hsh != Qnil) {
+            arr = rb_hash_aref(hsh, hsh_key);
+            if (arr == Qnil) {
+              arr = rb_ary_new();
+              rb_hash_aset(hsh, hsh_key, arr);
+            } else {
+              Check_Type(arr, T_ARRAY);
+            }
+            hsh = hsh_key = Qnil;
+          } else {
+            VALUE tmp = rb_hash_aref(params, k);
+            if (tmp != Qnil) {
+              Check_Type(tmp, T_ARRAY);
+              arr = tmp;
+            } else {
+              arr = rb_ary_new();
+              rb_hash_aset(params, k, arr);
+            }
+          }
+
+          pos += 2;
+
+        } else if (*pos == '[' && *(pos + 1) != ']') { // hash
+          if (pos + 2 < end) {
+            k_pos = memchr(pos + 2, ']', end - pos - 2);
+          } else {
+            k_pos = NULL;
+          }
+
+          if (!k_pos) {
+            rb_raise(rb_eRuntimeError, "Bad params");
+          }
+
+          VALUE prev_hsh_key = hsh_key;
+          hsh_key = ID2SYM(rb_intern2(pos + 1, k_pos - pos - 1));
+
+          if (hsh != Qnil) {
+            VALUE existing = rb_hash_aref(hsh, prev_hsh_key);
+            if (existing != Qnil) {
+              Check_Type(existing, T_HASH);
+              hsh = existing;
+            } else {
+              VALUE tmp = rb_hash_new();
+              rb_hash_aset(hsh, prev_hsh_key, tmp);
+              hsh = tmp;
+            }
+          } else if (arr != Qnil) {
+            VALUE nested_val = Qnil;
+            if (RARRAY_LEN(arr) != 0) {
+              VALUE tmp = rb_ary_entry(arr, -1);
+              Check_Type(tmp, T_HASH);
+              nested_val = rb_hash_aref(tmp, hsh_key);
+            }
+
+            // handle Rails' smart key grouping;
+            //   "users[][data][id]=11&users[][data][name]=ross&users[][data][id]=22&users[][data][name]=chandler"
+            // should result in:
+            //   { users: [{ data: { id: "11", name: "ross" } }, { data: { id: "22", name: "chandler" } }] }
+            if (RB_TYPE_P(nested_val, T_HASH)) {
+              char *n_pos_start = k_pos + 1, *n_pos_end = k_pos + 1;
+
+              while (nested_val != Qnil && *n_pos_start == '[' && *(n_pos_start + 1) != ']' && *n_pos_end != '&' && *n_pos_end != '=' && n_pos_end < end) {
+                n_pos_end++;
+
+                if (*n_pos_end == ']') {
+                  VALUE nested_key = ID2SYM(rb_intern2(n_pos_start + 1, n_pos_end - n_pos_start - 1));
+                  Check_Type(nested_val, T_HASH);
+                  nested_val = rb_hash_aref(nested_val, nested_key);
+                  n_pos_start = ++n_pos_end;
+                }
+              }
+            }
+
+            // use a new hash if there's none under this key or the existing one already has such key
+            if (RARRAY_LEN(arr) == 0 || nested_val != Qnil) {
+              hsh = rb_hash_new();
+              rb_ary_push(arr, hsh);
+            } else {
+              hsh = rb_ary_entry(arr, -1);
+              if (hsh != Qnil) {
+                Check_Type(hsh, T_HASH);
+              }
+            }
+
+            arr = Qnil;
+          } else {
+            VALUE tmp = rb_hash_aref(params, k);
+            if (tmp != Qnil) {
+              Check_Type(tmp, T_HASH);
+              hsh = tmp;
+            } else {
+              hsh = rb_hash_new();
+              rb_hash_aset(params, k, hsh);
+            }
+          }
+
+          pos = k_pos + 1;
+
+        } else {
+          pos++;
+        }
+      }
+
+      //
+      // write the final object into `params`
+      //
+
+      for (v_pos = pos + 1; *v_pos != '&' && v_pos < end; v_pos++) {
+        if (*v_pos == '%' || *v_pos == '+') {
+          should_decode = 1;
+        }
+      }
+
+      v = rb_str_new(pos + 1, v_pos - pos - 1);
+      if (should_decode) {
+        url_decode_inplace(Qnil, v);
+        should_decode = 0;
+      }
+
+      if (arr != Qnil) {
+        rb_ary_push(arr, v);
+      } else {
+        rb_hash_aset(hsh, hsh_key, v);
+      }
+
+      pos = k_pos = v_pos + 1;
+
+    } else if (*k_pos == '&' || k_pos >= end) {
+      VALUE k = ID2SYM(rb_intern2(pos, k_pos - pos));
+      rb_hash_aset(params, k, Qnil);
+      pos = k_pos + 1;
+    }
+  }
+
+  return params;
+}
+
+/**
+Convert query string into a Ruby object.
+*/
+static VALUE parse_nested_query(VALUE self, VALUE r_str) {
+  return parse_nested_query_internal(RSTRING_PTR(r_str), RSTRING_LEN(r_str));
+  (void)self;
+}
+
+/**
+Convert urlencoded body into a Ruby object.
+*/
+static VALUE parse_urlencoded_nested_query(VALUE self, VALUE r_str) {
+  ssize_t len = http_decode_url(RSTRING_PTR(r_str), RSTRING_PTR(r_str), RSTRING_LEN(r_str));
+  if (len < 0) {
+    rb_raise(rb_eRuntimeError, "Invalid encoding");
+  }
+  
+  return parse_nested_query_internal(RSTRING_PTR(r_str), len);
+  (void)self;
+}
+
+/**
+Convert multipart/form-data into a Ruby object.
+*/
+static VALUE parse_multipart(VALUE self, VALUE rack_io, VALUE content_type) {
+  http_s *h = IodineRackIO.get_handle(rack_io);
+
+  if (content_type == Qnil) {
+    rb_raise(rb_eRuntimeError, "Incorrect content type for multipart request");
+  }
+
+  return http_parse_multipart(h, RSTRING_PTR(content_type), RSTRING_LEN(content_type));
+  (void)self;
+}
+
 /* *****************************************************************************
 Ruby Initialization
 ***************************************************************************** */
@@ -261,6 +508,9 @@ Results:
   rb_define_module_function(tmp, "time2str", date_str, -1);
   rb_define_module_function(tmp, "rfc2109", iodine_rfc2109, 1);
   rb_define_module_function(tmp, "rfc2822", iodine_rfc2822, 1);
+  rb_define_module_function(tmp, "parse_nested_query", parse_nested_query, 1);
+  rb_define_module_function(tmp, "parse_urlencoded_nested_query", parse_urlencoded_nested_query, 1);
+  rb_define_module_function(tmp, "parse_multipart", parse_multipart, 2);
 
   /*
 The monkey-patched methods are in this module, allowing Iodine::Rack::Utils to

data/ext/iodine/iodine_http.c

@@ -106,6 +106,7 @@ 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_REQUEST_ID);
+rack_declare(IODINE_HAS_BODY);
 
 /* used internally to handle requests */
 typedef struct {
@@ -341,6 +342,9 @@ static inline VALUE copy2env(iodine_http_request_handle_s *handle) {
   tmp = fiobj_obj2cstr(h->path);
   rb_hash_aset(env, PATH_INFO,
                rb_enc_str_new(tmp.data, tmp.len, IodineBinaryEncoding));
+
+  rb_hash_aset(env, IODINE_HAS_BODY, (h->body) ? Qtrue : Qfalse);
+
   if (h->query) {
     tmp = fiobj_obj2cstr(h->query);
     rb_hash_aset(env, QUERY_STRING,
@@ -976,6 +980,7 @@ static void initialize_env_template(void) {
   rb_hash_aset(env_template_no_upgrade, SERVER_NAME, QUERY_STRING);
   rb_hash_aset(env_template_no_upgrade, SERVER_PROTOCOL, QUERY_STRING);
   rb_hash_aset(env_template_no_upgrade, IODINE_REQUEST_ID, QUERY_STRING);
+  rb_hash_aset(env_template_no_upgrade, IODINE_HAS_BODY, QUERY_STRING);
 
   /* WebSocket upgrade support */
   env_template_websockets = rb_hash_dup(env_template_no_upgrade);
@@ -1235,6 +1240,7 @@ void iodine_init_http(void) {
   rack_autoset(HTTP_HOST);
 
   rack_autoset(IODINE_REQUEST_ID);
+  rack_autoset(IODINE_HAS_BODY);
 
   rack_set(HTTP_SCHEME, "http");
   rack_set(HTTPS_SCHEME, "https");

data/ext/iodine/iodine_rack_io.c

@@ -270,4 +270,5 @@ struct IodineRackIO IodineRackIO = {
     .create = new_rack_io,
     .close = close_rack_io,
     .init = init_rack_io,
+    .get_handle = get_handle,
 };

data/ext/iodine/iodine_rack_io.h

@@ -15,6 +15,8 @@ extern struct IodineRackIO {
   VALUE (*create)(http_s *h, VALUE env);
   void (*close)(VALUE rack_io);
   void (*init)(void);
+  http_s * (*get_handle)(VALUE obj);
+
 } IodineRackIO;
 
 #endif /* RUBY_RACK_IO_H */

data/iodine.gemspec

@@ -44,7 +44,4 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rspec', '>=3.9.0', '< 4.0'
   spec.add_development_dependency 'spec', '>=5.3.0', '< 6.0'
   spec.add_development_dependency 'rake-compiler', '>= 1', '< 2.0'
-
-  spec.post_install_message = "Thank you for installing Iodine #{Iodine::VERSION}.\n" +
-                              "Remember: if iodine supports your business, it's only fair to give value back (code contributions / donations)."
 end

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '1.8.0'.freeze
+  VERSION = '2.0.0'.freeze
 end

data/lib/iodine.rb

@@ -1,5 +1,6 @@
 require 'stringio' # Used internally as a default RackIO
 require 'socket'  # TCPSocket is used internally for Hijack support
+require 'tempfile' # Used to generate temporary files when parsing multipart/form-data
 # require 'openssl' # For SSL/TLS support using OpenSSL
 
 require_relative './iodine/version'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rage-iodine
 version: !ruby/object:Gem::Version
-  version: 1.8.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Boaz Segev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-09-25 00:00:00.000000000 Z
+date: 2023-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -252,9 +252,7 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: |-
-  Thank you for installing Iodine 1.8.0.
-  Remember: if iodine supports your business, it's only fair to give value back (code contributions / donations).
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib