iodine 0.7.38 → 0.7.43

data/ext/iodine/iodine.c

@@ -33,6 +33,7 @@ VALUE IodineBaseModule;
 VALUE iodine_default_args;
 
 ID iodine_call_id;
+ID iodine_to_s_id;
 
 static VALUE address_sym;
 static VALUE app_sym;
@@ -1302,6 +1303,7 @@ void Init_iodine(void) {
   IodineBaseModule = rb_define_module_under(IodineModule, "Base");
   VALUE IodineCLIModule = rb_define_module_under(IodineBaseModule, "CLI");
   iodine_call_id = rb_intern2("call", 4);
+  iodine_to_s_id = rb_intern("to_s");
 
   // register core methods
   rb_define_module_function(IodineModule, "threads", iodine_threads_get, 0);

data/ext/iodine/iodine.h

@@ -53,6 +53,7 @@ extern VALUE IodineModule;
 extern VALUE IodineBaseModule;
 extern VALUE iodine_default_args;
 extern ID iodine_call_id;
+extern ID iodine_to_s_id;
 
 #define IODINE_RSTRINFO(rstr)                                                  \
   ((fio_str_info_s){.len = RSTRING_LEN(rstr), .data = RSTRING_PTR(rstr)})

data/ext/iodine/iodine_caller.c

@@ -5,7 +5,7 @@
 
 #include <fio.h>
 
-static __thread volatile uint8_t iodine_GVL_state;
+static __thread volatile uint8_t iodine_GVL_state = 1;
 
 /* *****************************************************************************
 Calling protected Ruby methods

data/ext/iodine/iodine_connection.c

@@ -159,7 +159,7 @@ Ruby Connection Methods - write, close open? pending
 ***************************************************************************** */
 
 /**
- * Writes data to the connection asynchronously.
+ * Writes data to the connection asynchronously. `data` MUST be a String.
  *
  * In effect, the `write` call does nothing, it only schedules the data to be
  * sent and marks the data as pending.
@@ -174,6 +174,16 @@ static VALUE iodine_connection_write(VALUE self, VALUE data) {
     return Qnil;
     // rb_raise(rb_eIOError, "Connection closed or invalid.");
   }
+  if (!RB_TYPE_P(data, T_STRING)) {
+    VALUE tmp = data;
+    data = IodineCaller.call(data, iodine_to_s_id);
+    if (!RB_TYPE_P(data, T_STRING))
+      Check_Type(tmp, T_STRING);
+    rb_backtrace();
+    FIO_LOG_WARNING(
+        "`Iodine::Connection#write` was called with a non-String object.");
+  }
+
   switch (c->info.type) {
   case IODINE_CONNECTION_WEBSOCKET:
     /* WebSockets*/
@@ -234,6 +244,14 @@ static VALUE iodine_connection_is_open(VALUE self) {
   }
   return Qfalse;
 }
+
+/**
+ * Always returns true, since Iodine connections support the pub/sub extension.
+ */
+static VALUE iodine_connection_is_pubsub(VALUE self) {
+  return INT2NUM(0);
+  (void)self;
+}
 /**
  * Returns the number of pending `write` operations that need to complete
  * before the next `on_drained` callback is called.
@@ -675,13 +693,6 @@ The method accepts an optional `engine` argument:
 
       publish(to, message, my_pubsub_engine)
 
-
-Alternatively, accepts the following named arguments:
-
-- `:to` - The channel to publish to (required).
-- `:message` - The message to be published (required).
-- `:engine` - If provided, the engine to use for pub/sub. Otherwise the default engine is used.
-
 */
 static VALUE iodine_pubsub_publish(int argc, VALUE *argv, VALUE self) {
   // clang-format on
@@ -903,6 +914,7 @@ void iodine_connection_init(void) {
                    0);
   rb_define_method(ConnectionKlass, "handler=", iodine_connection_handler_set,
                    1);
+  rb_define_method(ConnectionKlass, "pubsub?", iodine_connection_is_pubsub, 0);
   rb_define_method(ConnectionKlass, "subscribe", iodine_pubsub_subscribe, -1);
   rb_define_method(ConnectionKlass, "unsubscribe", iodine_pubsub_unsubscribe,
                    1);

data/ext/iodine/iodine_defer.c

@@ -181,6 +181,7 @@ static void iodine_defer_performe_once(void *block, void *ignr) {
 }
 
 static void iodine_defer_run_timer(void *block) {
+  /* TODO, update return value to allow timer cancellation */
   IodineCaller.call((VALUE)block, call_id);
 }
 

data/ext/iodine/iodine_http.c

@@ -51,7 +51,6 @@ static VALUE hijack_func_sym;
 static ID close_method_id;
 static ID each_method_id;
 static ID attach_method_id;
-static ID iodine_to_s_method_id;
 static ID iodine_call_proc_id;
 
 static VALUE env_template_no_upgrade;
@@ -294,9 +293,9 @@ static int iodine_copy2env_task(FIOBJ o, void *env_) {
 
   } else {
     /* it's an array */
-    VALUE ary = rb_ary_new();
-    rb_hash_aset(env, hname, ary);
     size_t count = fiobj_ary_count(o);
+    VALUE ary = rb_ary_new2(count);
+    rb_hash_aset(env, hname, ary);
     for (size_t i = 0; i < count; ++i) {
       tmp = fiobj_obj2cstr(fiobj_ary_index(o, i));
       rb_ary_push(ary, rb_enc_str_new(tmp.data, tmp.len, IodineBinaryEncoding));
@@ -476,11 +475,11 @@ static int for_each_header_data(VALUE key, VALUE val, VALUE h_) {
   http_s *h = (http_s *)h_;
   // fprintf(stderr, "For_each - headers\n");
   if (TYPE(key) != T_STRING)
-    key = IodineCaller.call(key, iodine_to_s_method_id);
+    key = IodineCaller.call(key, iodine_to_s_id);
   if (TYPE(key) != T_STRING)
     return ST_CONTINUE;
   if (TYPE(val) != T_STRING) {
-    val = IodineCaller.call(val, iodine_to_s_method_id);
+    val = IodineCaller.call(val, iodine_to_s_id);
     if (TYPE(val) != T_STRING)
       return ST_STOP;
   }
@@ -1130,7 +1129,6 @@ void iodine_init_http(void) {
   close_method_id = rb_intern("close");
   each_method_id = rb_intern("each");
   attach_method_id = rb_intern("attach_fd");
-  iodine_to_s_method_id = rb_intern("to_s");
   iodine_call_proc_id = rb_intern("call");
 
   IodineUTF8Encoding = rb_enc_find("UTF-8");

data/ext/iodine/iodine_mustache.c

@@ -8,7 +8,6 @@
 #include <fio.h>
 
 static ID call_func_id;
-static ID to_s_func_id;
 static VALUE filename_id;
 static VALUE data_id;
 static VALUE template_id;
@@ -169,7 +168,7 @@ static int mustache_on_arg(mustache_section_s *section, const char *name,
     if (rb_respond_to(o, call_func_id))
       o = IodineCaller.call(o, call_func_id);
     if (!RB_TYPE_P(o, T_STRING))
-      o = IodineCaller.call(o, to_s_func_id);
+      o = IodineCaller.call(o, iodine_to_s_id);
   }
   if (!RB_TYPE_P(o, T_STRING) || !RSTRING_LEN(o))
     return 0;
@@ -220,7 +219,7 @@ static int32_t mustache_on_section_test(mustache_section_s *section,
     }
     o = IodineCaller.call2(o, call_func_id, 1, &str);
     if (!RB_TYPE_P(o, T_STRING))
-      o = rb_funcall2(o, to_s_func_id, 0, NULL);
+      o = rb_funcall2(o, iodine_to_s_id, 0, NULL);
     if (RB_TYPE_P(o, T_STRING) && RSTRING_LEN(o))
       mustache_write_text(section, RSTRING_PTR(o), RSTRING_LEN(o), 0);
     return 0;
@@ -553,7 +552,6 @@ Initialize Iodine::Mustache
 
 void iodine_init_mustache(void) {
   call_func_id = rb_intern2("call", 4);
-  to_s_func_id = rb_intern2("to_s", 4);
   filename_id = rb_id2sym(rb_intern2("filename", 8));
   data_id = rb_id2sym(rb_intern2("data", 4));
   template_id = rb_id2sym(rb_intern2("template", 8));

data/ext/iodine/iodine_tls.c

@@ -208,22 +208,8 @@ static VALUE iodine_tls_alpn(VALUE self, VALUE protocol_name) {
 }
 
 /**
-Loads the mustache template found in `:filename`. If `:template` is provided
-it will be used instead of reading the file's content.
-
-    Iodine::Mustache.new(filename, template = nil)
-
-When template data is provided, filename (if any) will only be used for
-partial template path resolution and the template data will be used for the
-template's content. This allows, for example, for front matter to be extracted
-before parsing the template.
-
-Once a template was loaded, it could be rendered using {render}.
-
-Accepts named arguments as well:
-
-    Iodine::Mustache.new(filename: "foo.mustache", template: "{{ bar }}")
-
+Creates a new {Iodine::TLS} object and calles the {#use_certificate} method with
+the supplied arguments.
 */
 static VALUE iodine_tls_new(int argc, VALUE *argv, VALUE self) {
   if (argc) {

data/lib/iodine.rb

@@ -178,7 +178,7 @@ Iodine.on_state(:after_fork)  do
 end
 
 ### Parse CLI for default HTTP settings
-Iodine::Base::CLI.parse
+Iodine::Base::CLI.parse if defined?(IODINE_PARSE_CLI) && IODINE_PARSE_CLI
 
 ### Set default port (if missing)
 Iodine::DEFAULT_SETTINGS[:port] ||= (ENV["PORT"] || "3000")

data/lib/iodine/connection.rb

@@ -17,28 +17,40 @@ module Iodine
   # Instances of this class are passed to the callback objects. i.e.:
   #
   #     module MyConnectionCallbacks
+  #
   #       # called when the callback object is linked with a new client
   #       def on_open client
   #          client.is_a?(Iodine::Connection) # => true
   #       end
+  #
   #       # called when data is available
   #       def on_message client, data
   #          client.is_a?(Iodine::Connection) # => true
   #       end
+  #
   #       # called when the server is shutting down, before closing the client
   #       # (it's still possible to send messages to the client)
   #       def on_shutdown client
   #          client.is_a?(Iodine::Connection) # => true
   #       end
+  #
   #       # called when the client is closed (no longer available)
   #       def on_close client
   #          client.is_a?(Iodine::Connection) # => true
   #       end
+  #
   #       # called when all the previous calls to `client.write` have completed
   #       # (the local buffer was drained and is now empty)
   #       def on_drained client
   #          client.is_a?(Iodine::Connection) # => true
   #       end
+  #
+  #       # called when timeout was reached, llowing a `ping` to be sent
+  #       def ping client
+  #          client.is_a?(Iodine::Connection) # => true
+  #          clint.close() # close connection on timeout is the default
+  #       end
+  #
   #       # Allows the module to be used as a static callback object (avoiding object allocation)
   #       extend self
   #     end

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.7.38'.freeze
+  VERSION = '0.7.43'.freeze
 end

data/lib/rack/handler/iodine.rb

@@ -14,6 +14,12 @@ module Iodine
 
       true
     end
+
+    # patches an assumption by Rack, issue #98 code donated by @Shelvak (Néstor Coppi)
+    def self.shutdown
+      Iodine.stop
+    end
+
     IODINE_RACK_LOADED = true
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.7.38
+  version: 0.7.43
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-12-09 00:00:00.000000000 Z
+date: 2020-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -142,6 +142,7 @@ files:
 - bin/poc/config.ru
 - bin/poc/gemfile
 - bin/poc/www/index.html
+- examples/async_task.ru
 - examples/config.ru
 - examples/echo.ru
 - examples/hello.ru
@@ -188,7 +189,6 @@ files:
 - ext/iodine/http.h
 - ext/iodine/http1.c
 - ext/iodine/http1.h
-- ext/iodine/http1_parser.c
 - ext/iodine/http1_parser.h
 - ext/iodine/http_internal.c
 - ext/iodine/http_internal.h
@@ -244,7 +244,7 @@ licenses:
 metadata:
   allowed_push_host: https://rubygems.org
 post_install_message: |-
-  Thank you for installing Iodine 0.7.38.
+  Thank you for installing Iodine 0.7.43.
   Remember: if iodine supports your business, it's only fair to give value back (code contributions / donations).
 rdoc_options: []
 require_paths:
@@ -266,7 +266,7 @@ requirements:
 - Ruby >= 2.3.8 (Ruby EOL).
 - Ruby >= 2.5.0 recommended.
 - TLS requires OpenSSL >= 1.1.0
-rubygems_version: 3.0.1
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: iodine - a fast HTTP / Websocket Server with Pub/Sub support, optimized for

data/ext/iodine/http1_parser.c

@@ -1,616 +0,0 @@
-/*
-Copyright: Boaz Segev, 2017-2019
-License: MIT
-
-Feel free to copy, use and enjoy according to the license provided.
-*/
-#ifndef __GNU_SOURCE
-#define __GNU_SOURCE
-#endif
-
-#include <http1_parser.h>
-
-#include <ctype.h>
-#include <stdio.h>
-#include <string.h>
-
-/* *****************************************************************************
-Seeking for characters in a string
-***************************************************************************** */
-
-#ifndef ALLOW_UNALIGNED_MEMORY_ACCESS
-#define ALLOW_UNALIGNED_MEMORY_ACCESS 0
-#endif
-
-#ifndef HTTP_ADD_CONTENT_LENGTH_HEADER_IF_MISSING
-#define HTTP_ADD_CONTENT_LENGTH_HEADER_IF_MISSING 1
-#endif
-
-#if FIO_MEMCHAR
-
-/**
- * This seems to be faster on some systems, especially for smaller distances.
- *
- * On newer systems, `memchr` should be faster.
- */
-static int seek2ch(uint8_t **buffer, register uint8_t *const limit,
-                   const uint8_t c) {
-  if (*buffer >= limit)
-    return 0;
-
-  if (**buffer == c) {
-#if HTTP1_PARSER_CONVERT_EOL2NUL
-    **buffer = 0;
-#endif
-    return 1;
-  }
-
-#if !ALLOW_UNALIGNED_MEMORY_ACCESS || !defined(__x86_64__)
-  /* too short for this mess */
-  if ((uintptr_t)limit <= 16 + ((uintptr_t)*buffer & (~(uintptr_t)7)))
-    goto finish;
-
-  /* align memory */
-  {
-    const uint8_t *alignment =
-        (uint8_t *)(((uintptr_t)(*buffer) & (~(uintptr_t)7)) + 8);
-    if (limit >= alignment) {
-      while (*buffer < alignment) {
-        if (**buffer == c) {
-#if HTTP1_PARSER_CONVERT_EOL2NUL
-          **buffer = 0;
-#endif
-          return 1;
-        }
-        *buffer += 1;
-      }
-    }
-  }
-  const uint8_t *limit64 = (uint8_t *)((uintptr_t)limit & (~(uintptr_t)7));
-#else
-  const uint8_t *limit64 = (uint8_t *)limit - 7;
-#endif
-  uint64_t wanted1 = 0x0101010101010101ULL * c;
-  for (; *buffer < limit64; *buffer += 8) {
-    const uint64_t eq1 = ~((*((uint64_t *)*buffer)) ^ wanted1);
-    const uint64_t t0 = (eq1 & 0x7f7f7f7f7f7f7f7fllu) + 0x0101010101010101llu;
-    const uint64_t t1 = (eq1 & 0x8080808080808080llu);
-    if ((t0 & t1)) {
-      break;
-    }
-  }
-#if !ALLOW_UNALIGNED_MEMORY_ACCESS || !defined(__x86_64__)
-finish:
-#endif
-  while (*buffer < limit) {
-    if (**buffer == c) {
-#if HTTP1_PARSER_CONVERT_EOL2NUL
-      **buffer = 0;
-#endif
-      return 1;
-    }
-    (*buffer)++;
-  }
-  return 0;
-}
-
-#else
-
-/* a helper that seeks any char, converts it to NUL and returns 1 if found. */
-inline static uint8_t seek2ch(uint8_t **pos, uint8_t *const limit, uint8_t ch) {
-  /* This is library based alternative that is sometimes slower  */
-  if (*pos >= limit)
-    return 0;
-  if (**pos == ch) {
-    return 1;
-  }
-  uint8_t *tmp = memchr(*pos, ch, limit - (*pos));
-  if (tmp) {
-    *pos = tmp;
-#if HTTP1_PARSER_CONVERT_EOL2NUL
-    *tmp = 0;
-#endif
-    return 1;
-  }
-  *pos = limit;
-  return 0;
-}
-
-#endif
-
-/* a helper that seeks the EOL, converts it to NUL and returns it's length */
-inline static uint8_t seek2eol(uint8_t **pos, uint8_t *const limit) {
-  /* single char lookup using memchr might be better when target is far... */
-  if (!seek2ch(pos, limit, '\n'))
-    return 0;
-  if ((*pos)[-1] == '\r') {
-#if HTTP1_PARSER_CONVERT_EOL2NUL
-    (*pos)[-1] = 0;
-#endif
-    return 2;
-  }
-  return 1;
-}
-
-/* *****************************************************************************
-String to Number
-***************************************************************************** */
-
-/** Converts a String to a number using base 10 */
-static long long http1_atol(const uint8_t *buf, const uint8_t **end) {
-  register unsigned long long i = 0;
-  uint8_t inv = 0;
-  while (*buf == ' ' || *buf == '\t' || *buf == '\f')
-    ++buf;
-  while (*buf == '-' || *buf == '+')
-    inv ^= (*(buf++) == '-');
-  while (i <= ((((~0ULL) >> 1) / 10)) && *buf >= '0' && *buf <= '9') {
-    i = i * 10;
-    i += *buf - '0';
-    ++buf;
-  }
-  /* test for overflow */
-  if (i >= (~((~0ULL) >> 1)) || (*buf >= '0' && *buf <= '9'))
-    i = (~0ULL >> 1);
-  if (inv)
-    i = 0ULL - i;
-  if (end)
-    *end = buf;
-  return i;
-}
-
-/** Converts a String to a number using base 16, overflow limited to 113bytes */
-static long long http1_atol16(const uint8_t *buf, const uint8_t **end) {
-  register unsigned long long i = 0;
-  uint8_t inv = 0;
-  for (int limit_ = 0;
-       (*buf == ' ' || *buf == '\t' || *buf == '\f') && limit_ < 32; ++limit_)
-    ++buf;
-  for (int limit_ = 0; (*buf == '-' || *buf == '+') && limit_ < 32; ++limit_)
-    inv ^= (*(buf++) == '-');
-  if (*buf == '0')
-    ++buf;
-  if ((*buf | 32) == 'x')
-    ++buf;
-  for (int limit_ = 0; (*buf == '0') && limit_ < 32; ++limit_)
-    ++buf;
-  while (!(i & (~((~(0ULL)) >> 4)))) {
-    if (*buf >= '0' && *buf <= '9') {
-      i <<= 4;
-      i |= *buf - '0';
-    } else if ((*buf | 32) >= 'a' && (*buf | 32) <= 'f') {
-      i <<= 4;
-      i |= (*buf | 32) - ('a' - 10);
-    } else
-      break;
-    ++buf;
-  }
-  if (inv)
-    i = 0ULL - i;
-  if (end)
-    *end = buf;
-  return i;
-}
-
-/* *****************************************************************************
-HTTP/1.1 parsre stages
-***************************************************************************** */
-
-inline static int consume_response_line(struct http1_fio_parser_args_s *args,
-                                        uint8_t *start, uint8_t *end) {
-  args->parser->state.reserved |= 128;
-  uint8_t *tmp = start;
-  if (!seek2ch(&tmp, end, ' '))
-    return -1;
-  if (args->on_http_version(args->parser, (char *)start, tmp - start))
-    return -1;
-  tmp = start = tmp + 1;
-  if (!seek2ch(&tmp, end, ' '))
-    return -1;
-  if (args->on_status(args->parser, atol((char *)start), (char *)(tmp + 1),
-                      end - tmp))
-    return -1;
-  return 0;
-}
-
-inline static int consume_request_line(struct http1_fio_parser_args_s *args,
-                                       uint8_t *start, uint8_t *end) {
-  uint8_t *tmp = start;
-  uint8_t *host_start = NULL;
-  uint8_t *host_end = NULL;
-  if (!seek2ch(&tmp, end, ' '))
-    return -1;
-  if (args->on_method(args->parser, (char *)start, tmp - start))
-    return -1;
-  tmp = start = tmp + 1;
-  if (start[0] == 'h' && start[1] == 't' && start[2] == 't' &&
-      start[3] == 'p') {
-    if (start[4] == ':' && start[5] == '/' && start[6] == '/') {
-      /* Request URI is in long form... emulate Host header instead. */
-      tmp = host_end = host_start = (start += 7);
-    } else if (start[4] == 's' && start[5] == ':' && start[6] == '/' &&
-               start[7] == '/') {
-      /* Secure request is in long form... emulate Host header instead. */
-      tmp = host_end = host_start = (start += 8);
-    } else
-      goto review_path;
-    if (!seek2ch(&tmp, end, ' '))
-      return -1;
-    *tmp = ' ';
-    if (!seek2ch(&host_end, tmp, '/')) {
-      if (args->on_path(args->parser, (char *)"/", 1))
-        return -1;
-      goto start_version;
-    }
-    host_end[0] = '/';
-    start = host_end;
-  }
-review_path:
-  tmp = start;
-  if (seek2ch(&tmp, end, '?')) {
-    if (args->on_path(args->parser, (char *)start, tmp - start))
-      return -1;
-    tmp = start = tmp + 1;
-    if (!seek2ch(&tmp, end, ' '))
-      return -1;
-    if (tmp - start > 0 &&
-        args->on_query(args->parser, (char *)start, tmp - start))
-      return -1;
-  } else {
-    tmp = start;
-    if (!seek2ch(&tmp, end, ' '))
-      return -1;
-    if (args->on_path(args->parser, (char *)start, tmp - start))
-      return -1;
-  }
-start_version:
-  start = tmp + 1;
-  if (start + 5 >= end) /* require "HTTP/" */
-    return -1;
-  if (args->on_http_version(args->parser, (char *)start, end - start))
-    return -1;
-  /* */
-  if (host_start && args->on_header(args->parser, (char *)"host", 4,
-                                    (char *)host_start, host_end - host_start))
-    return -1;
-  return 0;
-}
-
-inline static int consume_header(struct http1_fio_parser_args_s *args,
-                                 uint8_t *start, uint8_t *end) {
-  uint8_t *end_name = start;
-  /* divide header name from data */
-  if (!seek2ch(&end_name, end, ':'))
-    return -1;
-#if HTTP_HEADERS_LOWERCASE
-  for (uint8_t *t = start; t < end_name; t++) {
-    *t = tolower(*t);
-  }
-#endif
-  uint8_t *start_value = end_name + 1;
-  if (start_value[0] == ' ') {
-    start_value++;
-  };
-
-  if ((end_name - start) == 14 &&
-#if HTTP1_UNALIGNED_MEMORY_ACCESS_ENABLED && HTTP_HEADERS_LOWERCASE
-      *((uint64_t *)start) == *((uint64_t *)"content-") &&
-      *((uint64_t *)(start + 6)) == *((uint64_t *)"t-length")
-#else
-      HEADER_NAME_IS_EQ((char *)start, "content-length", 14)
-#endif
-  ) {
-    /* handle the special `content-length` header */
-    args->parser->state.content_length = http1_atol(start_value, NULL);
-  } else if ((end_name - start) == 17 && (end - start_value) >= 7 &&
-#if HTTP1_UNALIGNED_MEMORY_ACCESS_ENABLED && HTTP_HEADERS_LOWERCASE
-             *((uint64_t *)start) == *((uint64_t *)"transfer") &&
-             *((uint64_t *)(start + 8)) == *((uint64_t *)"-encodin")
-#else
-             HEADER_NAME_IS_EQ((char *)start, "transfer-encoding", 17)
-#endif
-  ) {
-    /* handle the special `transfer-encoding: chunked` header? */
-    /* this removes the `chunked` marker and "unchunks" the data */
-    if (
-#if HTTP1_UNALIGNED_MEMORY_ACCESS_ENABLED
-        (((uint32_t *)(start_value))[0] | 0x20202020) ==
-            ((uint32_t *)"chun")[0] &&
-        (((uint32_t *)(start_value + 3))[0] | 0x20202020) ==
-            ((uint32_t *)"nked")[0]
-#else
-        ((start_value[0] | 32) == 'c' && (start_value[1] | 32) == 'h' &&
-         (start_value[2] | 32) == 'u' && (start_value[3] | 32) == 'n' &&
-         (start_value[4] | 32) == 'k' && (start_value[5] | 32) == 'e' &&
-         (start_value[6] | 32) == 'd')
-#endif
-    ) {
-      /* simple case,`chunked` at the beginning */
-      args->parser->state.reserved |= 64;
-      start_value += 7;
-      while (start_value < end && (*start_value == ',' || *start_value == ' '))
-        ++start_value;
-      if (!(end - start_value))
-        return 0;
-    } else if ((end - start_value) > 7 &&
-               ((end[(-7 + 0)] | 32) == 'c' && (end[(-7 + 1)] | 32) == 'h' &&
-                (end[(-7 + 2)] | 32) == 'u' && (end[(-7 + 3)] | 32) == 'n' &&
-                (end[(-7 + 4)] | 32) == 'k' && (end[(-7 + 5)] | 32) == 'e' &&
-                (end[(-7 + 6)] | 32) == 'd')) {
-      /* simple case,`chunked` at the end of list */
-      args->parser->state.reserved |= 64;
-      end -= 7;
-      while (start_value < end && (end[-1] == ',' || end[-1] == ' '))
-        --end;
-      if (!(end - start_value))
-        return 0;
-    } else if ((end - start_value) > 7 && (end - start_value) < 256) {
-      /* complex case, `the, chunked, marker, is in the middle of list */
-      uint8_t val[256];
-      size_t val_len = 0;
-      while (start_value < end) {
-        if (
-#if HTTP1_UNALIGNED_MEMORY_ACCESS_ENABLED
-            (((uint32_t *)(start_value))[0] | 0x20202020) ==
-                ((uint32_t *)"chun")[0] &&
-            (((uint32_t *)(start_value + 3))[0] | 0x20202020) ==
-                ((uint32_t *)"nked")[0]
-#else
-            ((start_value[0] | 32) == 'c' && (start_value[1] | 32) == 'h' &&
-             (start_value[2] | 32) == 'u' && (start_value[3] | 32) == 'n' &&
-             (start_value[4] | 32) == 'k' && (start_value[5] | 32) == 'e' &&
-             (start_value[6] | 32) == 'd')
-#endif
-
-        ) {
-          args->parser->state.reserved |= 64;
-          start_value += 7;
-          /* skip comma / white space */
-          while (start_value < end &&
-                 (*start_value == ',' || *start_value == ' '))
-            ++start_value;
-          break;
-        }
-        val[val_len++] = *start_value;
-        ++start_value;
-      }
-      while (start_value < end) {
-        val[val_len++] = *start_value;
-        ++start_value;
-      }
-      /* perform callback with `val` */
-      val[val_len] = 0;
-      if (val_len && args->on_header(args->parser, (char *)start,
-                                     (end_name - start), (char *)val, val_len))
-        return -1;
-      return 0;
-    }
-  } else if ((end_name - start) == 7 &&
-#if HTTP1_UNALIGNED_MEMORY_ACCESS_ENABLED && HTTP_HEADERS_LOWERCASE
-             *((uint64_t *)start) == *((uint64_t *)"trailer")
-#else
-             HEADER_NAME_IS_EQ((char *)start, "trailer", 7)
-#endif
-  ) {
-    /* chunked data with trailer... */
-    args->parser->state.reserved |= 64;
-    args->parser->state.reserved |= 32;
-    // return 0; /* hide Trailer header, since we process the headers? */
-  }
-
-  /* perform callback */
-  if (args->on_header(args->parser, (char *)start, (end_name - start),
-                      (char *)start_value, end - start_value))
-    return -1;
-  return 0;
-}
-
-/* *****************************************************************************
-HTTP/1.1 Body handling
-***************************************************************************** */
-
-inline static int consume_body_streamed(struct http1_fio_parser_args_s *args,
-                                        uint8_t **start) {
-  uint8_t *end =
-      *start + args->parser->state.content_length - args->parser->state.read;
-  uint8_t *const stop = ((uint8_t *)args->buffer) + args->length;
-  if (end > stop)
-    end = stop;
-  if (end > *start &&
-      args->on_body_chunk(args->parser, (char *)(*start), end - *start))
-    return -1;
-  args->parser->state.read += (end - *start);
-  *start = end;
-  if (args->parser->state.content_length <= args->parser->state.read)
-    args->parser->state.reserved |= 4;
-  return 0;
-}
-
-inline static int consume_body_chunked(struct http1_fio_parser_args_s *args,
-                                       uint8_t **start) {
-  uint8_t *const stop = ((uint8_t *)args->buffer) + args->length;
-  uint8_t *end = *start;
-  while (*start < stop) {
-    if (args->parser->state.content_length == 0) {
-      if (end + 2 >= stop)
-        return 0;
-      if ((end[0] == '\r' && end[1] == '\n')) {
-        /* remove tailing EOL that wasn't processed and retest */
-        end += 2;
-        *start = end;
-        if (end + 2 >= stop)
-          return 0;
-      }
-      long long chunk_len = http1_atol16(end, (const uint8_t **)&end);
-      if (end + 2 > stop) /* overflowed? */
-        return 0;
-      if ((end[0] != '\r' || end[1] != '\n'))
-        return -1; /* required EOL after content length */
-      end += 2;
-
-      args->parser->state.content_length = 0 - chunk_len;
-      *start = end;
-      if (args->parser->state.content_length == 0) {
-        /* all chunked data was parsed - update content-length */
-        args->parser->state.content_length = args->parser->state.read;
-        /* consume trailing EOL */
-        if (*start + 2 <= stop)
-          *start += 2;
-#ifdef HTTP_ADD_CONTENT_LENGTH_HEADER_IF_MISSING
-        { /* add virtual header ... ? */
-          char buf[512];
-          size_t buf_len = 512;
-          size_t tmp_len = args->parser->state.read;
-          buf[--buf_len] = 0;
-          while (tmp_len) {
-            size_t mod = tmp_len / 10;
-            buf[--buf_len] = '0' + (tmp_len - (mod * 10));
-            tmp_len = mod;
-          }
-          if (args->on_header(args->parser, "content-length", 14,
-                              (char *)buf + buf_len, 511 - buf_len))
-            return -1;
-        }
-#endif
-        if (args->parser->state.reserved & 32) {
-          /* remove the "headers complete" and "trailer" flags */
-          args->parser->state.reserved &= 0xDD; /* 0xDD == ~2 & ~32 & 0xFF */
-          return -2;
-        }
-        /* the parsing complete flag */
-        args->parser->state.reserved |= 4;
-        return 0;
-      }
-    }
-    end = *start + (0 - args->parser->state.content_length);
-    if (end > stop)
-      end = stop;
-    if (end > *start &&
-        args->on_body_chunk(args->parser, (char *)(*start), end - *start)) {
-      return -1;
-    }
-    args->parser->state.read += (end - *start);
-    args->parser->state.content_length += (end - *start);
-    *start = end;
-  }
-  return 0;
-}
-
-inline static int consume_body(struct http1_fio_parser_args_s *args,
-                               uint8_t **start) {
-  if (args->parser->state.content_length > 0 &&
-      args->parser->state.content_length > args->parser->state.read) {
-    /* normal, streamed data */
-    return consume_body_streamed(args, start);
-  } else if (args->parser->state.content_length <= 0 &&
-             (args->parser->state.reserved & 64)) {
-    /* chuncked encoding */
-    return consume_body_chunked(args, start);
-  } else {
-    /* nothing to do - parsing complete */
-    args->parser->state.reserved |= 4;
-  }
-  return 0;
-}
-
-/* *****************************************************************************
-HTTP/1.1 parsre function
-***************************************************************************** */
-#if DEBUG
-#include <assert.h>
-#else
-#define DEBUG 0
-#define assert(...)
-#endif
-
-size_t http1_fio_parser_fn(struct http1_fio_parser_args_s *args) {
-  assert(args->parser && args->buffer);
-  args->parser->state.next = NULL;
-  uint8_t *start = args->buffer;
-  uint8_t *end = start;
-  uint8_t *const stop = start + args->length;
-  uint8_t eol_len = 0;
-#define CONSUMED ((size_t)((uintptr_t)start - (uintptr_t)args->buffer))
-// fprintf(stderr, "** resuming with at %p with %.*s...(%lu)\n", args->buffer,
-// 4,
-//         start, args->length);
-re_eval:
-  switch ((args->parser->state.reserved & 15)) {
-
-  /* request / response line */
-  case 0:
-    /* clear out any leadinng white space */
-    while ((start < stop) &&
-           (*start == '\r' || *start == '\n' || *start == ' ' || *start == 0)) {
-      ++start;
-    }
-    end = start;
-    /* make sure the whole line is available*/
-    if (!(eol_len = seek2eol(&end, stop)))
-      return CONSUMED;
-
-    if (start[0] == 'H' && start[1] == 'T' && start[2] == 'T' &&
-        start[3] == 'P') {
-      /* HTTP response */
-      if (consume_response_line(args, start, end - eol_len + 1))
-        goto error;
-    } else if (tolower(start[0]) >= 'a' && tolower(start[0]) <= 'z') {
-      /* HTTP request */
-      if (consume_request_line(args, start, end - eol_len + 1))
-        goto error;
-    }
-    end = start = end + 1;
-    args->parser->state.reserved |= 1;
-
-  /* fallthrough */
-  /* headers */
-  case 1:
-    do {
-      if (start >= stop)
-        return CONSUMED; /* buffer ended on header line */
-      if (*start == '\r' || *start == '\n') {
-        goto finished_headers; /* empty line, end of headers */
-      }
-      if (!(eol_len = seek2eol(&end, stop)))
-        return CONSUMED;
-      if (consume_header(args, start, end - eol_len + 1))
-        goto error;
-      end = start = end + 1;
-    } while ((args->parser->state.reserved & 2) == 0);
-  finished_headers:
-    ++start;
-    if (*start == '\n')
-      ++start;
-    end = start;
-    args->parser->state.reserved |= 2;
-  /* fallthrough */
-  /* request body */
-  case 3: { /*  2 | 1 == 3 */
-    int t3 = consume_body(args, &start);
-    switch (t3) {
-    case -1:
-      goto error;
-    case -2:
-      goto re_eval;
-    }
-    break;
-  }
-  }
-  /* are we done ? */
-  if (args->parser->state.reserved & 4) {
-    args->parser->state.next = start;
-    if (((args->parser->state.reserved & 128) ? args->on_response
-                                              : args->on_request)(args->parser))
-      goto error;
-    args->parser->state =
-        (struct http1_parser_protected_read_only_state_s){0, 0, 0};
-  }
-  return CONSUMED;
-error:
-  args->on_error(args->parser);
-  args->parser->state =
-      (struct http1_parser_protected_read_only_state_s){0, 0, 0};
-  return args->length;
-}
-
-#undef CONSUMED