iodine 0.7.38 → 0.7.43

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);
@@ -797,7 +786,8 @@ fio_protocol_s *http1_new(uintptr_t uuid, http_settings_s *settings,
   if (unread_data && unread_length > HTTP_MAX_HEADER_LENGTH)
     return NULL;
   http1pr_s *p = fio_malloc(sizeof(*p) + HTTP_MAX_HEADER_LENGTH);
-  // FIO_LOG_DEBUG("Allocated HTTP/1.1 protocol at. %p", (void *)p);
+  // FIO_LOG_DEBUG("Allocated HTTP/1.1 protocol %p(%d)=>%p", (void *)uuid,
+  //               (int)fio_uuid2fd(uuid), (void *)p);
   FIO_ASSERT_ALLOC(p);
   *p = (http1pr_s){
       .p.protocol =
@@ -828,8 +818,9 @@ void http1_destroy(fio_protocol_s *pr) {
   http1pr_s *p = (http1pr_s *)pr;
   http1_pr2handle(p).status = 0;
   http_s_destroy(&http1_pr2handle(p), 0);
+  // FIO_LOG_DEBUG("Deallocating HTTP/1.1 protocol %p(%d)=>%p", (void
+  // *)p->p.uuid, (int)fio_uuid2fd(p->p.uuid), (void *)p);
   fio_free(p);
-  // FIO_LOG_DEBUG("Deallocated HTTP/1.1 protocol at. %p", (void *)p);
 }
 
 /* *****************************************************************************

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