iodine 0.7.37 → 0.7.42

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

@@ -28,6 +28,8 @@ typedef struct {
 } iodine_http_settings_s;
 
 /* these three are used also by iodin_rack_io.c */
+VALUE IODINE_R_INPUT_DEFAULT;
+VALUE IODINE_R_INPUT;
 VALUE IODINE_R_HIJACK;
 VALUE IODINE_R_HIJACK_IO;
 VALUE IODINE_R_HIJACK_CB;
@@ -846,6 +848,7 @@ static void initialize_env_template(void) {
     }
     add_str_to_env(env_template_no_upgrade, "SCRIPT_NAME", sn);
   }
+  rb_hash_aset(env_template_no_upgrade, IODINE_R_INPUT, IODINE_R_INPUT_DEFAULT);
   add_value_to_env(env_template_no_upgrade, "rack.errors", rb_stderr);
   add_value_to_env(env_template_no_upgrade, "rack.hijack?", Qtrue);
   add_value_to_env(env_template_no_upgrade, "rack.multiprocess", Qtrue);
@@ -1111,6 +1114,7 @@ void iodine_init_http(void) {
   rack_set(XSENDFILE_TYPE_HEADER, "HTTP_X_SENDFILE_TYPE");
   rack_set(CONTENT_LENGTH_HEADER, "Content-Length");
 
+  rack_set(IODINE_R_INPUT, "rack.input");
   rack_set(IODINE_R_HIJACK_IO, "rack.hijack_io");
   rack_set(IODINE_R_HIJACK, "rack.hijack");
   rack_set(IODINE_R_HIJACK_CB, "iodine.hijack_cb");
@@ -1132,5 +1136,12 @@ void iodine_init_http(void) {
   IodineUTF8Encoding = rb_enc_find("UTF-8");
   IodineBinaryEncoding = rb_enc_find("binary");
 
+  {
+    VALUE STRIO_CLASS = rb_const_get(rb_cObject, rb_intern("StringIO"));
+    IODINE_R_INPUT_DEFAULT = rb_str_new_static("", 0);
+    IODINE_R_INPUT_DEFAULT =
+        rb_funcallv(STRIO_CLASS, rb_intern("new"), 1, &IODINE_R_INPUT_DEFAULT);
+    rb_global_variable(&IODINE_R_INPUT_DEFAULT);
+  }
   initialize_env_template();
 }

data/ext/iodine/iodine_http.h

@@ -9,6 +9,8 @@ Feel free to copy, use and enjoy according to the license provided.
 #include "iodine.h"
 
 /* these three are used also by rb-rack-io.c */
+extern VALUE IODINE_R_INPUT;
+extern VALUE IODINE_R_INPUT_DEFAULT;
 extern VALUE IODINE_R_HIJACK;
 extern VALUE IODINE_R_HIJACK_IO;
 extern VALUE IODINE_R_HIJACK_CB;

data/ext/iodine/iodine_rack_io.c

@@ -216,7 +216,7 @@ static VALUE new_rack_io(http_s *h, VALUE env) {
   rb_ivar_set(rack_io, io_id, ULL2NUM(h->body));
   set_handle(rack_io, h);
   rb_ivar_set(rack_io, env_id, env);
-  rb_hash_aset(env, R_INPUT, rack_io);
+  rb_hash_aset(env, IODINE_R_INPUT, rack_io);
   rb_hash_aset(env, IODINE_R_HIJACK, rb_obj_method(rack_io, hijack_func_sym));
   return rack_io;
 }
@@ -240,10 +240,6 @@ static void init_rack_io(void) {
   iodine_new_func_id = rb_intern("new");
   hijack_func_sym = ID2SYM(rb_intern("_hijack"));
 
-  R_INPUT = rb_enc_str_new("rack.input", 10, rb_ascii8bit_encoding());
-  rb_obj_freeze(R_INPUT);
-  IodineStore.add(R_INPUT);
-
   TCPSOCKET_CLASS = rb_const_get(rb_cObject, rb_intern("TCPSocket"));
   // IO methods
 

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/iodine.gemspec

@@ -33,7 +33,7 @@ Gem::Specification.new do |spec|
 
   spec.requirements << 'A Unix based system: Linux / macOS / BSD.'
   spec.requirements << 'An updated C compiler.'
-  spec.requirements << 'Ruby >= 2.2.2 required for Rack 2.'
+  spec.requirements << 'Ruby >= 2.3.8 (Ruby EOL).'
   spec.requirements << 'Ruby >= 2.5.0 recommended.'
   spec.requirements << 'TLS requires OpenSSL >= 1.1.0'
 

data/lib/iodine.rb

@@ -1,3 +1,4 @@
+require 'stringio' # Used internally as a default RackIO
 require 'socket'  # TCPSocket is used internally for Hijack support
 # require 'openssl' # For SSL/TLS support using OpenSSL
 
@@ -177,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.37'.freeze
+  VERSION = '0.7.42'.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.37
+  version: 0.7.42
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-11-13 00:00:00.000000000 Z
+date: 2020-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -121,6 +121,7 @@ extensions:
 - ext/iodine/extconf.rb
 extra_rdoc_files: []
 files:
+- ".github/ISSUE_TEMPLATE/bug_report.md"
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
@@ -187,7 +188,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
@@ -243,7 +243,7 @@ licenses:
 metadata:
   allowed_push_host: https://rubygems.org
 post_install_message: |-
-  Thank you for installing Iodine 0.7.37.
+  Thank you for installing Iodine 0.7.42.
   Remember: if iodine supports your business, it's only fair to give value back (code contributions / donations).
 rdoc_options: []
 require_paths:
@@ -262,10 +262,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements:
 - 'A Unix based system: Linux / macOS / BSD.'
 - An updated C compiler.
-- Ruby >= 2.2.2 required for Rack 2.
+- 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,460 +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
-
-#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 == 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 (*buffer < alignment)
-      *buffer += 1; /* already tested this char */
-    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 || **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;
-}
-
-/* *****************************************************************************
-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 ALLOW_UNALIGNED_MEMORY_ACCESS && HTTP_HEADERS_LOWERCASE
-  /* enable this section to test unaligned memory access */
-  if ((end_name - start) == 14 &&
-      *((uint64_t *)start) == *((uint64_t *)"content-") &&
-      *((uint64_t *)(start + 6)) == *((uint64_t *)"t-length")) {
-    /* handle the special `content-length` header */
-    args->parser->state.content_length = atol((char *)start_value);
-  } else if ((end_name - start) == 17 &&
-             *((uint64_t *)start) == *((uint64_t *)"transfer") &&
-             *((uint64_t *)(start + 8)) == *((uint64_t *)"-encodin") &&
-             *((uint32_t *)start_value) == *((uint32_t *)"chun") &&
-             *((uint32_t *)(start_value + 3)) == *((uint32_t *)"nked")) {
-    /* handle the special `transfer-encoding: chunked` header */
-    args->parser->state.reserved |= 64;
-  } else if ((end_name - start) == 7 &&
-             *((uint64_t *)start) == *((uint64_t *)"trailer")) {
-    /* chunked data with trailer... */
-    args->parser->state.reserved |= 64;
-    args->parser->state.reserved |= 32;
-  }
-#else
-  if ((end_name - start) == 14 &&
-      HEADER_NAME_IS_EQ((char *)start, "content-length", 14)) {
-    /* handle the special `content-length` header */
-    args->parser->state.content_length = atol((char *)start_value);
-  } else if ((end_name - start) == 17 &&
-             HEADER_NAME_IS_EQ((char *)start, "transfer-encoding", 17) &&
-             memcmp(start_value, "chunked", 7)) {
-    /* handle the special `transfer-encoding: chunked` header */
-    args->parser->state.reserved |= 64;
-  } else if ((end_name - start) == 7 &&
-             HEADER_NAME_IS_EQ((char *)start, "trailer", 7)) {
-    /* chunked data with trailer... */
-    args->parser->state.reserved |= 64;
-    args->parser->state.reserved |= 32;
-  }
-#endif
-  /* 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) {
-      size_t eol_len;
-      /* consume seperator */
-      while (*start < stop && (**start == '\n' || **start == '\r'))
-        ++(*start);
-      /* collect chunked length */
-      if (!(eol_len = seek2eol(&end, stop))) {
-        /* requires length data to continue */
-        return 0;
-      }
-      /* an empty EOL is possible in mid stream processing */
-      if (*start + eol_len > end && (*start = end) && !seek2eol(&end, stop)) {
-        return 0;
-      }
-      args->parser->state.content_length = 0 - strtol((char *)*start, NULL, 16);
-      *start = end = end + 1;
-      if (args->parser->state.content_length == 0) {
-        /* all chunked data was parsed */
-        args->parser->state.content_length = args->parser->state.read;
-        /* consume trailing EOL */
-        if (seek2eol(start, stop))
-          (*start)++;
-        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