iodine 0.7.38 → 0.7.39

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 698e63218598fd769063529e151ab15aab31e413365a6e80130e464adac9eea3
-  data.tar.gz: d4b146805592a1ef5476461c349eeb31069a3213af7257caeaaccbd91b6f1929
+  metadata.gz: ad7a8dc81e2698056037086bfd6dd2f24ee975229a928092ac039ae9c44cb0d7
+  data.tar.gz: 84ff62b2c79efe4b0f5f1d796e27e6513bc8a29414fbd771404c814567d1138c
 SHA512:
-  metadata.gz: bc9d26dacd98d979d1e110eaa4c7ac04451c8332658a7be2004bd54b9d9f94adf1e55f2ee5407fd2e9f0c27295f32f9f40c3667ae42cee5fb6f76bd1a3000b8c
-  data.tar.gz: 224db61d880f272de498cd766d40e9641ade6fceb7c0626ba88a5cca3244561b542f846df8102a22dcb48b88b2bc2f4943a6b30d102391c36f3dde7f3ff8b9af
+  metadata.gz: bc69044b0cac72fda7be13ffb6e039007282f07e6b2607ea23e0a97733250d1b883d5e9cee171c67095e4eebd623f04f4d9d08ee2067f5a42a923b6785e3b824
+  data.tar.gz: b182b80a365fabaa0b97ce312f4bd2033ed28ba5a07759674cd305486f7a43ae64704da76449a84379be1a844ffe2df9396a863f4e8df5a9883d796be9fc3a91

data/.github/ISSUE_TEMPLATE/bug_report.md

@@ -9,10 +9,10 @@ assignees: ''
 
 ### System Information
 
- - **OS**:             [e.g. macOS 10.14.6]
- - **Ruby**:         [e.g. 2.6.1]
- - **Version**:     [e.g. 0.7.37]
- - **OpenSSL**:  [OpenSSL 1.1.1d 10 Sep 2019]
+ - **OS**:             [e.g. macOS 10.15.4]
+ - **Ruby**:         [e.g. 2.7.0]
+ - **Version**:     [e.g. 0.7.38]
+ - **OpenSSL**:  [OpenSSL 1.1.1f 20 Mar 2020]
 
 ### Description
 
@@ -37,11 +37,4 @@ A clear and concise description of what you expected to happen.
 
 ### Actual behavior
 
-**Smartphone (please complete the following information):**
- - Device: [e.g. iPhone6]
- - OS: [e.g. iOS8.1]
- - Browser [e.g. stock browser, safari]
- - Version [e.g. 22]
-
-**Additional context**
-Add any other context about the problem here.
+A clear and concise description of what actually happened.

data/CHANGELOG.md

@@ -6,6 +6,14 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.0.7.39 (2020-05-18)
+
+**Security**: a request smuggling attack vector and Transfer Encoding attack vector in the HTTP/1.1 parser were exposed by Sam Sanoop from [the Snyk Security team (snyk.io)](https://snyk.io). The parser was updated to deal with these potential issues.
+
+**Fix**: (`http`) fixes an issue with date calculation - exposed by Franck Gille (@fgi) in issue #92.
+
+**Fix**: (`extconf`) fixes an installation concern raised by Benoit Daloze (@eregon), in issue #91. The default compiler is now used.
+
 #### Change log v.0.7.38
 
 **Fix**: (`http`) fixes an issue and improves support for chunked encoded payloads. Credit to Ian Ker-Seymer ( @ianks ) for exposing this, writing tests and opening both the issue #87 and the PR #88.

data/README.md

@@ -1,4 +1,5 @@
-# iodine - a fast HTTP / Websocket Server with native Pub/Sub support for the new web
+# iodine - Why Settle for a fast HTTP / WebSocket Server with native Pub/Sub?
+
 [![Gem](https://img.shields.io/gem/dt/iodine.svg)](https://rubygems.org/gems/iodine)
 [![Build Status](https://travis-ci.org/boazsegev/iodine.svg?branch=master)](https://travis-ci.org/boazsegev/iodine)
 [![Gem Version](https://badge.fury.io/rb/iodine.svg)](https://badge.fury.io/rb/iodine)
@@ -7,28 +8,29 @@
 
 [![Logo](https://github.com/boazsegev/iodine/raw/master/logo.png)](https://github.com/boazsegev/iodine)
 
-I believe that network concerns should be separated from application concerns - application developers really shouldn't need to worry about the transport layer.
+Iodine is a fast concurrent web application server for real-time Ruby applications, with native support for WebSockets and Pub/Sub services - but it's also so much more.
 
-And I know that these network concerns are more than just about the web server, which is why iodine is more than just an HTTP server.
+Iodine is a Ruby wrapper for many of the [facil.io](https://facil.io) C framework, leveraging the speed of C for many common web application tasks. In addition, iodine abstracts away all network concerns, so you never need to worry about the transport layer, free to concentrate on your application logic.
 
-Iodine is a fast concurrent web server for real-time Ruby applications, but it's also so much more. Iodine includes native support for:
+Iodine includes native support for:
 
 * HTTP, WebSockets and EventSource (SSE) Services (server);
 * WebSocket connections (server / client);
 * Pub/Sub (with optional Redis Pub/Sub scaling);
-* Static file service (with automatic `gzip` support for pre-compressed versions);
-* HTTP/1.1 keep-alive and pipelining;
+* Fast(!) builtin Mustache template engine.
+* Static file service (with automatic `gzip` support for pre-compressed assets);
 * Asynchronous event scheduling and timers;
-* Hot Restart (using the USR1 signal);
+* HTTP/1.1 keep-alive and pipelining;
 * TLS 1.2 and above (Requires OpenSSL >= 1.1.0);
 * TCP/IP server and client connectivity;
 * Unix Socket server and client connectivity;
+* Hot Restart (using the USR1 signal);
 * Custom protocol authoring;
 * Optimized Logging to `stderr`.
 * [Sequel](https://github.com/jeremyevans/sequel) and ActiveRecord forking protection.
 * and more!
 
-Iodine is an **evented** framework with a simple API that ports much of the [C facil.io framework](https://github.com/boazsegev/facil.io) to Ruby. This means that:
+Since iodine wraps much of the [C facil.io framework](https://github.com/boazsegev/facil.io) to Ruby:
 
 * Iodine can handle **thousands of concurrent connections** (tested with more then 20K connections on Linux)!
 
@@ -36,9 +38,9 @@ Iodine is an **evented** framework with a simple API that ports much of the [C f
 
 Iodine is a C extension for Ruby, developed and optimized for Ruby MRI 2.2.2 and up... it should support the whole Ruby 2.0 MRI family, but CI tests start at Ruby 2.2.2.
 
-**Note**: iodine does **not** support the streaming when using Rack. Streaming over Rack should be avoided on any server, WebSockets, SSE and `Range` requests should always be preferred. On iodine no data will be sent before the whole of the data is available.
+**Note**: iodine does **not** support streaming when using Rack. It's recommended to avoid blocking the server when using `body.each` since the `each` loop will block the iodine's thread until it's finished and iodine won't send any data before the loop is done.
 
-## Iodine - a fast & powerful HTTP + Websockets server with native Pub/Sub
+## Iodine - a fast & powerful HTTP + WebSockets server with native Pub/Sub
 
 Iodine includes a light and fast HTTP and Websocket server written in C that was written according to the [Rack interface specifications](http://www.rubydoc.info/github/rack/rack/master/file/SPEC) and the [Websocket draft extension](./SPEC-Websocket-Draft.md).
 
@@ -770,6 +772,14 @@ Yes, please, here are some thoughts:
 
 * If you love the project or thought the code was nice, maybe helped you in your own project, drop me a line. I'd love to know.
 
+### Running the Tests
+
+Running this task will compile the C extensions then run RSpec tests:
+
+```sh
+bundle exec rake spec
+```
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -3,10 +3,12 @@ require "rake/extensiontask"
 
 begin
   require 'rspec/core/rake_task'
-  RSpec::Core::RakeTask.new(:spec)
+  RSpec::Core::RakeTask.new(:rspec)
 rescue LoadError
 end
 
+task :spec => [:compile, :rspec]
+
 task :default => [:compile, :spec]
 
 Rake::ExtensionTask.new "iodine" do |ext|

data/ext/iodine/extconf.rb

@@ -1,34 +1,5 @@
 require 'mkmf'
 
-if ENV['CC']
-  ENV['CPP'] ||= ENV['CC']
-  puts "detected user prefered compiler (#{ENV['CC']}):", `#{ENV['CC']} -v`
-elsif find_executable('clang') && puts('testing clang for stdatomic support...').nil? && system("printf \"\#include <stdatomic.h>\nint main(void) {}\" | clang -include stdatomic.h -xc -o /dev/null -", out: '/dev/null')
-  $CC = ENV['CC'] = 'clang'
-  $CPP = ENV['CPP'] = 'clang'
-  puts "using clang compiler v. #{`clang -dumpversion`}."
-elsif find_executable('gcc') && (`gcc -dumpversion 2>&1`.to_i >= 5)
-  $CC = ENV['CC'] = 'gcc'
-  $CPP = ENV['CPP'] = find_executable('g++') ? 'g++' : 'gcc'
-  puts "using gcc #{ `gcc -dumpversion 2>&1`.to_i }"
-elsif find_executable('gcc-6')
-  $CC = ENV['CC'] = 'gcc-6'
-  $CPP = ENV['CPP'] = find_executable('g++-6') ? 'g++-6' : 'gcc-6'
-  puts 'using gcc-6 compiler.'
-elsif find_executable('gcc-5')
-  $CC = ENV['CC'] = 'gcc-5'
-  $CPP = ENV['CPP'] = find_executable('g++-5') ? 'g++-5' : 'gcc-5'
-  puts 'using gcc-5 compiler.'
-elsif find_executable('gcc-4.9')
-  $CC = ENV['CC'] = 'gcc-4.9'
-  $CPP = ENV['CPP'] = find_executable('g++-4.9') ? 'g++-4.9' : 'gcc-4.9'
-  puts 'using gcc-4.9 compiler.'
-else
-  puts 'using an unknown (old?) compiler... who knows if this will work out... we hope.'
-end
-
-
-
 # Test polling
 def iodine_test_polling_support
   iodine_poll_test_kqueue = <<EOS
@@ -129,10 +100,5 @@ EOS
     end
   end
 end
-# $defs << "-DFIO_USE_RISKY_HASH"
-
-RbConfig::MAKEFILE_CONFIG['CFLAGS'] = $CFLAGS = "-std=c11 -DFIO_PRINT_STATE=0 #{$CFLAGS} #{$CFLAGS == ENV['CFLAGS'] ? "" : ENV['CFLAGS']}"
-RbConfig::MAKEFILE_CONFIG['CC'] = $CC = ENV['CC'] if ENV['CC']
-RbConfig::MAKEFILE_CONFIG['CPP'] = $CPP = ENV['CPP'] if ENV['CPP']
 
 create_makefile 'iodine/iodine'

data/ext/iodine/http.c

@@ -2089,111 +2089,94 @@ See the libc `gmtime_r` documentation for details.
 
 Falls back to `gmtime_r` for dates before epoch.
 */
-struct tm *http_gmtime(time_t timer, struct tm *tmbuf) {
-  // static char* DAYS[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri",
-  // "Sat"}; static char * Months = {  "Jan", "Feb", "Mar", "Apr", "May",
-  // "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
-  static const uint8_t month_len[] = {
-      31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, // nonleap year
-      31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31  // leap year
-  };
-  if (timer < 0)
-    return gmtime_r(&timer, tmbuf);
+struct tm *http_gmtime(time_t timer, struct tm *tm) {
   ssize_t a, b;
-#if HAVE_TM_TM_ZONE
-  *tmbuf = (struct tm){
+#if HAVE_TM_TM_ZONE || defined(BSD)
+  *tm = (struct tm){
       .tm_isdst = 0,
-      .tm_year = 70, // tm_year == The number of years since 1900
-      .tm_mon = 0,
-      .tm_zone = "UTC",
+      .tm_zone = (char *)"UTC",
   };
 #else
-  *tmbuf = (struct tm){
+  *tm = (struct tm){
       .tm_isdst = 0,
-      .tm_year = 70, // tm_year == The number of years since 1900
-      .tm_mon = 0,
   };
 #endif
-  // for seconds up to weekdays, we build up, as small values clean up
-  // larger values.
-  a = (ssize_t)timer;
-  b = a / 60;
-  tmbuf->tm_sec = a - (b * 60);
-  a = b / 60;
-  tmbuf->tm_min = b - (a * 60);
-  b = a / 24;
-  tmbuf->tm_hour = a - (b * 24);
-  // day of epoch was a thursday. Add + 4 so sunday == 0...
-  tmbuf->tm_wday = (b + 4) % 7;
-// tmp == number of days since epoch
-#define DAYS_PER_400_YEARS ((400 * 365) + 97)
-  while (b >= DAYS_PER_400_YEARS) {
-    tmbuf->tm_year += 400;
-    b -= DAYS_PER_400_YEARS;
-  }
-#undef DAYS_PER_400_YEARS
-#define DAYS_PER_100_YEARS ((100 * 365) + 24)
-  while (b >= DAYS_PER_100_YEARS) {
-    tmbuf->tm_year += 100;
-    b -= DAYS_PER_100_YEARS;
-    if (((tmbuf->tm_year / 100) & 3) ==
-        0) // leap century divisable by 400 => add leap
+
+  // convert seconds from epoch to days from epoch + extract data
+  if (timer >= 0) {
+    // for seconds up to weekdays, we reduce the reminder every step.
+    a = (ssize_t)timer;
+    b = a / 60; // b == time in minutes
+    tm->tm_sec = a - (b * 60);
+    a = b / 60; // b == time in hours
+    tm->tm_min = b - (a * 60);
+    b = a / 24; // b == time in days since epoch
+    tm->tm_hour = a - (b * 24);
+    // b == number of days since epoch
+    // day of epoch was a thursday. Add + 4 so sunday == 0...
+    tm->tm_wday = (b + 4) % 7;
+  } else {
+    // for seconds up to weekdays, we reduce the reminder every step.
+    a = (ssize_t)timer;
+    b = a / 60; // b == time in minutes
+    if (b * 60 != a) {
+      /* seconds passed */
+      tm->tm_sec = (a - (b * 60)) + 60;
       --b;
-  }
-#undef DAYS_PER_100_YEARS
-#define DAYS_PER_32_YEARS ((32 * 365) + 8)
-  while (b >= DAYS_PER_32_YEARS) {
-    tmbuf->tm_year += 32;
-    b -= DAYS_PER_32_YEARS;
-  }
-#undef DAYS_PER_32_YEARS
-#define DAYS_PER_8_YEARS ((8 * 365) + 2)
-  while (b >= DAYS_PER_8_YEARS) {
-    tmbuf->tm_year += 8;
-    b -= DAYS_PER_8_YEARS;
-  }
-#undef DAYS_PER_8_YEARS
-#define DAYS_PER_4_YEARS ((4 * 365) + 1)
-  while (b >= DAYS_PER_4_YEARS) {
-    tmbuf->tm_year += 4;
-    b -= DAYS_PER_4_YEARS;
-  }
-#undef DAYS_PER_4_YEARS
-  while (b >= 365) {
-    tmbuf->tm_year += 1;
-    b -= 365;
-    if ((tmbuf->tm_year & 3) == 0) { // leap year
-      if (b > 0) {
-        --b;
-        continue;
-      } else {
-        b += 365;
-        --tmbuf->tm_year;
-        break;
-      }
+    } else {
+      /* no seconds */
+      tm->tm_sec = 0;
     }
-  }
-  b++; /* day 1 of the year is 1, not 0. */
-  tmbuf->tm_yday = b;
-  if ((tmbuf->tm_year & 3) == 1) {
-    // regular year
-    for (size_t i = 0; i < 12; i++) {
-      if (b <= month_len[i])
-        break;
-      b -= month_len[i];
-      ++tmbuf->tm_mon;
+    a = b / 60; // b == time in hours
+    if (a * 60 != b) {
+      /* minutes passed */
+      tm->tm_min = (b - (a * 60)) + 60;
+      --a;
+    } else {
+      /* no minutes */
+      tm->tm_min = 0;
     }
-  } else {
-    // leap year
-    for (size_t i = 12; i < 24; i++) {
-      if (b <= month_len[i])
-        break;
-      b -= month_len[i];
-      ++tmbuf->tm_mon;
+    b = a / 24; // b == time in days since epoch?
+    if (b * 24 != a) {
+      /* hours passed */
+      tm->tm_hour = (a - (b * 24)) + 24;
+      --b;
+    } else {
+      /* no hours */
+      tm->tm_hour = 0;
     }
+    // day of epoch was a thursday. Add + 4 so sunday == 0...
+    tm->tm_wday = ((b - 3) % 7);
+    if (tm->tm_wday)
+      tm->tm_wday += 7;
+    /* b == days from epoch */
   }
-  tmbuf->tm_mday = b;
-  return tmbuf;
+
+  // at this point we can apply the algorithm described here:
+  // http://howardhinnant.github.io/date_algorithms.html#civil_from_days
+  // Credit to Howard Hinnant.
+  {
+    b += 719468L; // adjust to March 1st, 2000 (post leap of 400 year era)
+    // 146,097 = days in era (400 years)
+    const size_t era = (b >= 0 ? b : b - 146096) / 146097;
+    const uint32_t doe = (b - (era * 146097)); // day of era
+    const uint16_t yoe =
+        (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365; // year of era
+    a = yoe;
+    a += era * 400; // a == year number, assuming year starts on March 1st...
+    const uint16_t doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+    const uint16_t mp = (5U * doy + 2) / 153;
+    const uint16_t d = doy - (153U * mp + 2) / 5 + 1;
+    const uint8_t m = mp + (mp < 10 ? 2 : -10);
+    a += (m <= 1);
+    tm->tm_year = a - 1900; // tm_year == years since 1900
+    tm->tm_mon = m;
+    tm->tm_mday = d;
+    const uint8_t is_leap = (a % 4 == 0 && (a % 100 != 0 || a % 400 == 0));
+    tm->tm_yday = (doy + (is_leap) + 28 + 31) % (365 + is_leap);
+  }
+
+  return tm;
 }
 
 static const char *DAY_NAMES[] = {"Sun", "Mon", "Tue", "Wed",

data/ext/iodine/http1.c

@@ -599,8 +599,7 @@ static int http1_on_query(http1_parser_s *parser, char *query, size_t len) {
   return 0;
 }
 /** called when a the HTTP/1.x version is parsed. */
-static int http1_on_http_version(http1_parser_s *parser, char *version,
-                                 size_t len) {
+static int http1_on_version(http1_parser_s *parser, char *version, size_t len) {
   http1_pr2handle(parser2http(parser)).version = fiobj_str_new(version, len);
   parser2http(parser)->header_size += len;
 /* start counting - occurs on the first line of both requests and responses */
@@ -687,17 +686,7 @@ static inline void http1_consume_data(intptr_t uuid, http1pr_s *p) {
   if (!p->buf_len)
     return;
   do {
-    i = http1_fio_parser(.parser = &p->parser,
-                         .buffer = p->buf + (org_len - p->buf_len),
-                         .length = p->buf_len, .on_request = http1_on_request,
-                         .on_response = http1_on_response,
-                         .on_method = http1_on_method,
-                         .on_status = http1_on_status, .on_path = http1_on_path,
-                         .on_query = http1_on_query,
-                         .on_http_version = http1_on_http_version,
-                         .on_header = http1_on_header,
-                         .on_body_chunk = http1_on_body_chunk,
-                         .on_error = http1_on_error);
+    i = http1_parse(&p->parser, p->buf + (org_len - p->buf_len), p->buf_len);
     p->buf_len -= i;
     --pipeline_limit;
   } while (i && p->buf_len && pipeline_limit && !p->stop);

data/ext/iodine/http1_parser.h

@@ -1,6 +1,6 @@
 #ifndef H_HTTP1_PARSER_H
 /*
-Copyright: Boaz Segev, 2017-2019
+Copyright: Boaz Segev, 2017-2020
 License: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
@@ -9,29 +9,32 @@ Feel free to copy, use and enjoy according to the license provided.
 /**
 This is a callback based parser. It parses the skeleton of the HTTP/1.x protocol
 and leaves most of the work (validation, error checks, etc') to the callbacks.
-
-This is an attempt to replace the existing HTTP/1.x parser with something easier
-to maintain and that could be used for an HTTP/1.x client as well.
 */
 #define H_HTTP1_PARSER_H
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <sys/types.h>
 
+/* *****************************************************************************
+Parser Settings
+***************************************************************************** */
+
 #ifndef HTTP_HEADERS_LOWERCASE
 /**
- * when defined, HTTP headers will be converted to lowercase and header
+ * When defined, HTTP headers will be converted to lowercase and header
  * searches will be case sensitive.
  *
- * this is required by facil.io and helps with HTTP/2 compatibility.
+ * This is highly recommended, required by facil.io and helps with HTTP/2
+ * compatibility.
  */
 #define HTTP_HEADERS_LOWERCASE 1
 #endif
 
-#ifndef HTTP1_PARSER_CONVERT_EOL2NUL
-#define HTTP1_PARSER_CONVERT_EOL2NUL 0
+#ifndef HTTP_ADD_CONTENT_LENGTH_HEADER_IF_MISSING
+#define HTTP_ADD_CONTENT_LENGTH_HEADER_IF_MISSING 1
 #endif
 
 #ifndef FIO_MEMCHAR
@@ -39,65 +42,727 @@ to maintain and that could be used for an HTTP/1.x client as well.
 #define FIO_MEMCHAR 0
 #endif
 
-#if HTTP_HEADERS_LOWERCASE
+#ifndef ALLOW_UNALIGNED_MEMORY_ACCESS
+/** Peforms some optimizations assuming unaligned memory access is okay. */
+#define ALLOW_UNALIGNED_MEMORY_ACCESS 0
+#endif
 
-#define HEADER_NAME_IS_EQ(var_name, const_name, len)                           \
-  (!memcmp((var_name), (const_name), (len)))
-#else
-#define HEADER_NAME_IS_EQ(var_name, const_name, len)                           \
-  (!strncasecmp((var_name), (const_name), (len)))
+#ifndef HTTP1_PARSER_CONVERT_EOL2NUL
+#define HTTP1_PARSER_CONVERT_EOL2NUL 0
 #endif
 
+/* *****************************************************************************
+Parser API
+***************************************************************************** */
+
 /** this struct contains the state of the parser. */
 typedef struct http1_parser_s {
-  void *udata;
   struct http1_parser_protected_read_only_state_s {
-    ssize_t content_length; /* negative values indicate chuncked data state */
-    ssize_t read;           /* total number of bytes read so far (body only) */
+    long long content_length; /* negative values indicate chuncked data state */
+    ssize_t read;     /* total number of bytes read so far (body only) */
     uint8_t *next;    /* the known position for the end of request/response */
     uint8_t reserved; /* for internal use */
   } state;
 } http1_parser_s;
 
+#define HTTP1_PARSER_INIT                                                      \
+  {                                                                            \
+    { 0 }                                                                      \
+  }
+
+/**
+ * Returns the amount of data actually consumed by the parser.
+ *
+ * The value 0 indicates there wasn't enough data to be parsed and the same
+ * buffer (with more data) should be resubmitted.
+ *
+ * A value smaller than the buffer size indicates that EITHER a request /
+ * response was detected OR that the leftover could not be consumed because more
+ * data was required.
+ *
+ * Simply resubmit the reminder of the data to continue parsing.
+ *
+ * A request / response callback automatically stops the parsing process,
+ * allowing the user to adjust or refresh the state of the data.
+ */
+static size_t http1_parse(http1_parser_s *parser, void *buffer, size_t length);
+
+/* *****************************************************************************
+Required Callbacks (MUST be implemented by including file)
+***************************************************************************** */
+
+/** called when a request was received. */
+static int http1_on_request(http1_parser_s *parser);
+/** called when a response was received. */
+static int http1_on_response(http1_parser_s *parser);
+/** called when a request method is parsed. */
+static int http1_on_method(http1_parser_s *parser, char *method,
+                           size_t method_len);
+/** called when a response status is parsed. the status_str is the string
+ * without the prefixed numerical status indicator.*/
+static int http1_on_status(http1_parser_s *parser, size_t status,
+                           char *status_str, size_t len);
+/** called when a request path (excluding query) is parsed. */
+static int http1_on_path(http1_parser_s *parser, char *path, size_t path_len);
+/** called when a request path (excluding query) is parsed. */
+static int http1_on_query(http1_parser_s *parser, char *query,
+                          size_t query_len);
+/** called when a the HTTP/1.x version is parsed. */
+static int http1_on_version(http1_parser_s *parser, char *version, size_t len);
+/** called when a header is parsed. */
+static int http1_on_header(http1_parser_s *parser, char *name, size_t name_len,
+                           char *data, size_t data_len);
+/** called when a body chunk is parsed. */
+static int http1_on_body_chunk(http1_parser_s *parser, char *data,
+                               size_t data_len);
+/** called when a protocol error occurred. */
+static int http1_on_error(http1_parser_s *parser);
+
+/* *****************************************************************************
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+                        Implementation Details
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+***************************************************************************** */
+
+#if HTTP_HEADERS_LOWERCASE
+#define HEADER_NAME_IS_EQ(var_name, const_name, len)                           \
+  (!memcmp((var_name), (const_name), (len)))
+#else
+#define HEADER_NAME_IS_EQ(var_name, const_name, len)                           \
+  (!strncasecmp((var_name), (const_name), (len)))
+#endif
+
+#define HTTP1_P_FLAG_STATUS_LINE 1
+#define HTTP1_P_FLAG_HEADER_COMPLETE 2
+#define HTTP1_P_FLAG_COMPLETE 4
+#define HTTP1_P_FLAG_CLENGTH 8
+#define HTTP1_PARSER_BIT_16 16
+#define HTTP1_PARSER_BIT_32 32
+#define HTTP1_P_FLAG_CHUNKED 64
+#define HTTP1_P_FLAG_RESPONSE 128
+
+/* *****************************************************************************
+Seeking for characters in a string
+***************************************************************************** */
+
+#if FIO_MEMCHAR
+
 /**
- * Available options for the parsing function.
+ * This seems to be faster on some systems, especially for smaller distances.
  *
- * Callbacks should return 0 unless an error occurred.
+ * On newer systems, `memchr` should be faster.
  */
-struct http1_fio_parser_args_s {
-  /** REQUIRED: the parser object that manages the parser's state. */
-  http1_parser_s *parser;
-  /** REQUIRED: the data to be parsed. */
-  void *buffer;
-  /** REQUIRED: the length of the data to be parsed. */
-  size_t length;
-  /** called when a request was received. */
-  int (*const on_request)(http1_parser_s *parser);
-  /** called when a response was received. */
-  int (*const on_response)(http1_parser_s *parser);
-  /** called when a request method is parsed. */
-  int (*const on_method)(http1_parser_s *parser, char *method,
-                         size_t method_len);
-  /** called when a response status is parsed. the status_str is the string
-   * without the prefixed numerical status indicator.*/
-  int (*const on_status)(http1_parser_s *parser, size_t status,
-                         char *status_str, size_t len);
-  /** called when a request path (excluding query) is parsed. */
-  int (*const on_path)(http1_parser_s *parser, char *path, size_t path_len);
-  /** called when a request path (excluding query) is parsed. */
-  int (*const on_query)(http1_parser_s *parser, char *query, size_t query_len);
-  /** called when a the HTTP/1.x version is parsed. */
-  int (*const on_http_version)(http1_parser_s *parser, char *version,
-                               size_t len);
-  /** called when a header is parsed. */
-  int (*const on_header)(http1_parser_s *parser, char *name, size_t name_len,
-                         char *data, size_t data_len);
-  /** called when a body chunk is parsed. */
-  int (*const on_body_chunk)(http1_parser_s *parser, char *data,
-                             size_t data_len);
-  /** called when a protocol error occurred. */
-  int (*const on_error)(http1_parser_s *parser);
-};
+static int seek2ch(uint8_t **buffer, register uint8_t *const limit,
+                   const uint8_t c) {
+  if (*buffer >= limit)
+    return 0;
+  if (**buffer == c) {
+    return 1;
+  }
+
+#if !HTTP1_UNALIGNED_MEMORY_ACCESS_ENABLED
+  /* 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 (*buffer < alignment)
+      *buffer += 1; /* we already tested this char */
+    if (limit >= alignment) {
+      while (*buffer < alignment) {
+        if (**buffer == c) {
+          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 !HTTP1_UNALIGNED_MEMORY_ACCESS_ENABLED
+finish:
+#endif
+  while (*buffer < limit) {
+    if (**buffer == c) {
+      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;
+    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] = (*pos)[0] = 0;
+#endif
+    return 2;
+  }
+#if HTTP1_PARSER_CONVERT_EOL2NUL
+  (*pos)[0] = 0;
+#endif
+  return 1;
+}
+
+/* *****************************************************************************
+Change a letter to lower case (latin only)
+***************************************************************************** */
+
+static uint8_t http_tolower(uint8_t c) {
+  if (c >= 'A' && c <= 'Z')
+    c |= 32;
+  return c;
+}
+
+/* *****************************************************************************
+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 http1_consume_response_line(http1_parser_s *parser,
+                                              uint8_t *start, uint8_t *end) {
+  parser->state.reserved |= HTTP1_P_FLAG_RESPONSE;
+  uint8_t *tmp = start;
+  if (!seek2ch(&tmp, end, ' '))
+    return -1;
+  if (http1_on_version(parser, (char *)start, tmp - start))
+    return -1;
+  tmp = start = tmp + 1;
+  if (!seek2ch(&tmp, end, ' '))
+    return -1;
+  if (http1_on_status(parser, http1_atol(start, NULL), (char *)(tmp + 1),
+                      end - tmp))
+    return -1;
+  return 0;
+}
+
+inline static int http1_consume_request_line(http1_parser_s *parser,
+                                             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 (http1_on_method(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 (http1_on_path(parser, (char *)"/", 1))
+        return -1;
+      goto start_version;
+    }
+    host_end[0] = '/';
+    start = host_end;
+  }
+review_path:
+  tmp = start;
+  if (seek2ch(&tmp, end, '?')) {
+    if (http1_on_path(parser, (char *)start, tmp - start))
+      return -1;
+    tmp = start = tmp + 1;
+    if (!seek2ch(&tmp, end, ' '))
+      return -1;
+    if (tmp - start > 0 && http1_on_query(parser, (char *)start, tmp - start))
+      return -1;
+  } else {
+    tmp = start;
+    if (!seek2ch(&tmp, end, ' '))
+      return -1;
+    if (http1_on_path(parser, (char *)start, tmp - start))
+      return -1;
+  }
+start_version:
+  start = tmp + 1;
+  if (start + 5 >= end) /* require "HTTP/" */
+    return -1;
+  if (http1_on_version(parser, (char *)start, end - start))
+    return -1;
+  /* */
+  if (host_start && http1_on_header(parser, (char *)"host", 4,
+                                    (char *)host_start, host_end - host_start))
+    return -1;
+  return 0;
+}
+
+#ifndef HTTP1_ALLOW_CHUNKED_IN_MIDDLE_OF_HEADER
+inline /* inline the function of it's short enough */
+#endif
+    static int
+    http1_consume_header_transfer_encoding(http1_parser_s *parser,
+                                           uint8_t *start, uint8_t *end_name,
+                                           uint8_t *start_value, uint8_t *end) {
+  /* this removes the `chunked` marker and prepares to "unchunk" the data */
+  while (start_value < end && (end[-1] == ',' || end[-1] == ' '))
+    --end;
+  if ((end - start_value) == 7 &&
+#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,only `chunked` as a value */
+    parser->state.reserved |= HTTP1_P_FLAG_CHUNKED;
+    parser->state.content_length = 0;
+    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 (RFC required) */
+    parser->state.reserved |= HTTP1_P_FLAG_CHUNKED;
+    parser->state.content_length = 0;
+    end -= 7;
+    while (start_value < end && (end[-1] == ',' || end[-1] == ' '))
+      --end;
+    if (!(end - start_value))
+      return 0;
+  }
+#ifdef HTTP1_ALLOW_CHUNKED_IN_MIDDLE_OF_HEADER /* RFC diisallows this */
+  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 && val_len < 256) {
+      if ((end - start_value) >= 7) {
+        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
+
+        ) {
+          parser->state.reserved |= HTTP1_P_FLAG_CHUNKED;
+          parser->state.content_length = 0;
+          start_value += 7;
+          /* skip comma / white space */
+          while (start_value < end &&
+                 (*start_value == ',' || *start_value == ' '))
+            ++start_value;
+          continue;
+        }
+      }
+      /* copy value */
+      while (start_value < end && val_len < 256 && start_value[0] != ',') {
+        val[val_len++] = *start_value;
+        ++start_value;
+      }
+      /* copy comma */
+      if (start_value[0] == ',' && val_len < 256) {
+        val[val_len++] = *start_value;
+        ++start_value;
+      }
+      /* skip spaces */
+      while (start_value < end && start_value[0] == ' ') {
+        ++start_value;
+      }
+    }
+    if (val_len < 256) {
+      while (start_value < end && val_len < 256) {
+        val[val_len++] = *start_value;
+        ++start_value;
+      }
+      val[val_len] = 0;
+    }
+    /* perform callback with `val` or indicate error */
+    if (val_len == 256 ||
+        (val_len && http1_on_header(parser, (char *)start, (end_name - start),
+                                    (char *)val, val_len)))
+      return -1;
+    return 0;
+  }
+#endif /* HTTP1_ALLOW_CHUNKED_IN_MIDDLE_OF_HEADER */
+  /* perform callback */
+  if (http1_on_header(parser, (char *)start, (end_name - start),
+                      (char *)start_value, end - start_value))
+    return -1;
+  return 0;
+}
+inline static int http1_consume_header_top(http1_parser_s *parser,
+                                           uint8_t *start, uint8_t *end_name,
+                                           uint8_t *start_value, uint8_t *end) {
+  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 */
+    if ((parser->state.reserved & HTTP1_P_FLAG_CHUNKED))
+      return 0; /* ignore if `chunked` */
+    long long old_clen = parser->state.content_length;
+    parser->state.content_length = http1_atol(start_value, NULL);
+    if ((parser->state.reserved & HTTP1_P_FLAG_CLENGTH) &&
+        old_clen != parser->state.content_length) {
+      /* content-length header repeated with conflict */
+      return -1;
+    }
+    parser->state.reserved |= HTTP1_P_FLAG_CLENGTH;
+  } else if ((end_name - start) == 17 && (end - start_value) >= 7 &&
+             !parser->state.content_length &&
+#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 */
+    return http1_consume_header_transfer_encoding(parser, start, end_name,
+                                                  start_value, end);
+  }
+  /* perform callback */
+  if (http1_on_header(parser, (char *)start, (end_name - start),
+                      (char *)start_value, end - start_value))
+    return -1;
+  return 0;
+}
+
+inline static int http1_consume_header_trailer(http1_parser_s *parser,
+                                               uint8_t *start,
+                                               uint8_t *end_name,
+                                               uint8_t *start_value,
+                                               uint8_t *end) {
+  if ((end_name - start) > 1 && start[0] == 'x') {
+    /* X- headers are allowed */
+    goto white_listed;
+  }
+
+  /* white listed trailer names */
+  const struct {
+    char *name;
+    long len;
+  } http1_trailer_white_list[] = {
+      {"server-timing", 13}, /* specific for client data... */
+      {NULL, 0},             /* end of list marker */
+  };
+  for (size_t i = 0; http1_trailer_white_list[i].name; ++i) {
+    if ((long)(end_name - start) == http1_trailer_white_list[i].len &&
+        HEADER_NAME_IS_EQ((char *)start, http1_trailer_white_list[i].name,
+                          http1_trailer_white_list[i].len)) {
+      /* header disallowed here */
+      goto white_listed;
+    }
+  }
+  return 0;
+white_listed:
+  /* perform callback */
+  if (http1_on_header(parser, (char *)start, (end_name - start),
+                      (char *)start_value, end - start_value))
+    return -1;
+  return 0;
+}
+
+inline static int http1_consume_header(http1_parser_s *parser, uint8_t *start,
+                                       uint8_t *end) {
+  uint8_t *end_name = start;
+  /* divide header name from data */
+  if (!seek2ch(&end_name, end, ':'))
+    return -1;
+  if (end_name[-1] == ' ' || end_name[-1] == '\t')
+    return -1;
+#if HTTP_HEADERS_LOWERCASE
+  for (uint8_t *t = start; t < end_name; t++) {
+    *t = http_tolower(*t);
+  }
+#endif
+  uint8_t *start_value = end_name + 1;
+  // clear away leading white space from value.
+  while (start_value < end &&
+         (start_value[0] == ' ' || start_value[0] == '\t')) {
+    start_value++;
+  };
+  return (parser->state.read ? http1_consume_header_trailer
+                             : http1_consume_header_top)(
+      parser, start, end_name, start_value, end);
+}
+
+/* *****************************************************************************
+HTTP/1.1 Body handling
+***************************************************************************** */
+
+inline static int http1_consume_body_streamed(http1_parser_s *parser,
+                                              void *buffer, size_t length,
+                                              uint8_t **start) {
+  uint8_t *end = *start + parser->state.content_length - parser->state.read;
+  uint8_t *const stop = ((uint8_t *)buffer) + length;
+  if (end > stop)
+    end = stop;
+  if (end > *start &&
+      http1_on_body_chunk(parser, (char *)(*start), end - *start))
+    return -1;
+  parser->state.read += (end - *start);
+  *start = end;
+  if (parser->state.content_length <= parser->state.read)
+    parser->state.reserved |= HTTP1_P_FLAG_COMPLETE;
+  return 0;
+}
+
+inline static int http1_consume_body_chunked(http1_parser_s *parser,
+                                             void *buffer, size_t length,
+                                             uint8_t **start) {
+  uint8_t *const stop = ((uint8_t *)buffer) + length;
+  uint8_t *end = *start;
+  while (*start < stop) {
+    if (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;
+
+      parser->state.content_length = 0 - chunk_len;
+      *start = end;
+      if (parser->state.content_length == 0) {
+        /* all chunked data was parsed */
+        /* update content-length */
+        parser->state.content_length = parser->state.read;
+#ifdef HTTP_ADD_CONTENT_LENGTH_HEADER_IF_MISSING
+        { /* add virtual header ... ? */
+          char buf[512];
+          size_t buf_len = 512;
+          size_t tmp_len = 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 (!(parser->state.reserved & HTTP1_P_FLAG_CLENGTH) &&
+              http1_on_header(parser, "content-length", 14,
+                              (char *)buf + buf_len, 511 - buf_len)) {
+            return -1;
+          }
+        }
+#endif
+        /* FIXME: consume trailing EOL */
+        if (*start + 2 <= stop && (start[0][0] == '\r' || start[0][0] == '\n'))
+          *start += 1 + (start[0][1] == '\r' || start[0][1] == '\n');
+        else {
+          /* remove the "headers complete" and "trailer" flags */
+          parser->state.reserved =
+              HTTP1_P_FLAG_STATUS_LINE | HTTP1_P_FLAG_CLENGTH;
+          return -2;
+        }
+        /* the parsing complete flag */
+        parser->state.reserved |= HTTP1_P_FLAG_COMPLETE;
+        return 0;
+      }
+    }
+    end = *start + (0 - parser->state.content_length);
+    if (end > stop)
+      end = stop;
+    if (end > *start &&
+        http1_on_body_chunk(parser, (char *)(*start), end - *start)) {
+      return -1;
+    }
+    parser->state.read += (end - *start);
+    parser->state.content_length += (end - *start);
+    *start = end;
+  }
+  return 0;
+}
+
+inline static int http1_consume_body(http1_parser_s *parser, void *buffer,
+                                     size_t length, uint8_t **start) {
+  if (parser->state.content_length > 0 &&
+      parser->state.content_length > parser->state.read) {
+    /* normal, streamed data */
+    return http1_consume_body_streamed(parser, buffer, length, start);
+  } else if (parser->state.content_length <= 0 &&
+             (parser->state.reserved & HTTP1_P_FLAG_CHUNKED)) {
+    /* chuncked encoding */
+    return http1_consume_body_chunked(parser, buffer, length, start);
+  } else {
+    /* nothing to do - parsing complete */
+    parser->state.reserved |= HTTP1_P_FLAG_COMPLETE;
+  }
+  return 0;
+}
+
+/* *****************************************************************************
+HTTP/1.1 parsre function
+***************************************************************************** */
+#if DEBUG
+#include <assert.h>
+#define HTTP1_ASSERT assert
+#else
+#define HTTP1_ASSERT(...)
+#endif
 
 /**
  * Returns the amount of data actually consumed by the parser.
@@ -114,17 +779,95 @@ struct http1_fio_parser_args_s {
  * A request / response callback automatically stops the parsing process,
  * allowing the user to adjust or refresh the state of the data.
  */
-size_t http1_fio_parser_fn(struct http1_fio_parser_args_s *args);
-
-static inline __attribute__((unused)) size_t
-http1_fio_parser(struct http1_fio_parser_args_s args) {
-  if (!args.length)
+static size_t http1_parse(http1_parser_s *parser, void *buffer, size_t length) {
+  if (!length)
     return 0;
-  return http1_fio_parser_fn(&args);
+  HTTP1_ASSERT(parser && buffer);
+  parser->state.next = NULL;
+  uint8_t *start = (uint8_t *)buffer;
+  uint8_t *end = start;
+  uint8_t *const stop = start + length;
+  uint8_t eol_len = 0;
+#define HTTP1_CONSUMED ((size_t)((uintptr_t)start - (uintptr_t)buffer))
+
+re_eval:
+  switch ((parser->state.reserved & 7)) {
+
+  case 0: /* request / response line */
+    /* clear out any leading 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 HTTP1_CONSUMED;
+
+    if (start[0] == 'H' && start[1] == 'T' && start[2] == 'T' &&
+        start[3] == 'P') {
+      /* HTTP response */
+      if (http1_consume_response_line(parser, start, end - eol_len + 1))
+        goto error;
+    } else if (http_tolower(start[0]) >= 'a' && http_tolower(start[0]) <= 'z') {
+      /* HTTP request */
+      if (http1_consume_request_line(parser, start, end - eol_len + 1))
+        goto error;
+    } else
+      goto error;
+    end = start = end + 1;
+    parser->state.reserved |= HTTP1_P_FLAG_STATUS_LINE;
+
+  /* fallthrough */
+  case 1: /* headers */
+    do {
+      if (start >= stop)
+        return HTTP1_CONSUMED; /* buffer ended on header line */
+      if (*start == '\r' || *start == '\n') {
+        goto finished_headers; /* empty line, end of headers */
+      }
+      end = start;
+      if (!(eol_len = seek2eol(&end, stop)))
+        return HTTP1_CONSUMED;
+      if (http1_consume_header(parser, start, end - eol_len + 1))
+        goto error;
+      end = start = end + 1;
+    } while ((parser->state.reserved & HTTP1_P_FLAG_HEADER_COMPLETE) == 0);
+  finished_headers:
+    ++start;
+    if (*start == '\n')
+      ++start;
+    end = start;
+    parser->state.reserved |= HTTP1_P_FLAG_HEADER_COMPLETE;
+  /* fallthrough */
+  case (HTTP1_P_FLAG_HEADER_COMPLETE | HTTP1_P_FLAG_STATUS_LINE):
+    /* request body */
+    {
+      int t3 = http1_consume_body(parser, buffer, length, &start);
+      switch (t3) {
+      case -1:
+        goto error;
+      case -2:
+        goto re_eval;
+      }
+      break;
+    }
+  }
+  /* are we done ? */
+  if (parser->state.reserved & HTTP1_P_FLAG_COMPLETE) {
+    parser->state.next = start;
+    if (((parser->state.reserved & HTTP1_P_FLAG_RESPONSE)
+             ? http1_on_response
+             : http1_on_request)(parser))
+      goto error;
+    parser->state = (struct http1_parser_protected_read_only_state_s){0};
+  }
+  return HTTP1_CONSUMED;
+error:
+  http1_on_error(parser);
+  parser->state = (struct http1_parser_protected_read_only_state_s){0};
+  return length;
+#undef HTTP1_CONSUMED
 }
-#if __STDC_VERSION__ >= 199901L
-#define http1_fio_parser(...)                                                  \
-  http1_fio_parser((struct http1_fio_parser_args_s){__VA_ARGS__})
-#endif
 
 #endif