kcar 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 11fd8bf65267d66726c60a780beb44140d7ce64e
-  data.tar.gz: a6508831c72ee890f06a1a6b70858b15a3817ddb
+SHA256:
+  metadata.gz: f7cd96d8a5fa081a4e6ac36feb24d3a737f428550da5fa589ab564c516d01820
+  data.tar.gz: 7383af40cdd8bc3ec9954feb4199d0f89ad04fb468633e22e515f6dd70ffc075
 SHA512:
-  metadata.gz: 7c28c23285c4c881749facc72bb8388b7e66d8231201b1b5ac87c83ddb2482d8b9324ea47d450eae0e63cdccb2b5bb2f42274ca9835276a92b0cabe7b6ab90c8
-  data.tar.gz: 2b5ee78603d2e7e36df30e60b06bf3f701b1aa240655b8df84f71e91b0254333b587c2be955816505673b1a92eb234f0151f39ff7e6749c80e540ad9cb645821
+  metadata.gz: cccb634b38dc4d944f3a216c2f2acafbc563e6efa782643d6ff845f8b09e5338fe285c1d862cab8363ab1598298b6ed1f05d0509c2fa1153adb5f946be45fddb
+  data.tar.gz: 92f1e61ef2049429835403ddc964179fb611ace06ce33a29f20fd3659db629ae05f532bf473efd44372192e476acea23cc09347bc271d2e0bdff42a70d99add2

data/.document

@@ -1,5 +1,6 @@
 LICENSE
 README
 NEWS
+HACKING
 lib
 ext/kcar/kcar.c

data/.olddoc.yml

@@ -1,7 +1,14 @@
 ---
-cgit_url: http://bogomips.org/kcar.git
-git_url: git://bogomips.org/kcar.git
-rdoc_url: http://bogomips.org/kcar/
-ml_url: http://bogomips.org/kcar-public/
-private_email: kcar@bogomips.org
-public_email: kcar-public@bogomips.org
+cgit_url: https://yhbt.net/kcar.git
+git_url: https://yhbt.net/kcar.git
+rdoc_url: https://yhbt.net/kcar/
+ml_url:
+- https://yhbt.net/kcar-public/
+- http://ou63pmih66umazou.onion/kcar-public/
+public_email: kcar-public@yhbt.net
+source_code:
+- git clone https://yhbt.net/kcar.git
+- torsocks git clone http://ou63pmih66umazou.onion/kcar.git
+nntp_url:
+- nntp://news.public-inbox.org/inbox.comp.lang.ruby.kcar
+- nntp://ou63pmih66umazou.onion/inbox.comp.lang.ruby.kcar

data/GIT-VERSION-GEN

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 CONSTANT = "Kcar::VERSION"
 RVF = "lib/kcar/version.rb"
-DEF_VER = "v0.6.0"
+DEF_VER = "v0.7.0"
 GVF = "GIT-VERSION-FILE"
 vn = DEF_VER
 
@@ -21,7 +21,7 @@ if File.exist?(".git")
 end
 
 vn = vn.sub!(/\Av/, "")
-new_ruby_version = "#{CONSTANT} = '#{vn}'\n"
+new_ruby_version = "#{CONSTANT} = '#{vn}' # :nodoc:\n"
 cur_ruby_version = File.read(RVF) rescue nil
 if new_ruby_version != cur_ruby_version
   File.open(RVF, "w") { |fp| fp.write(new_ruby_version) }

data/GNUmakefile

@@ -1,5 +1,5 @@
 all::
-RSYNC_DEST := bogomips.org:/srv/bogomips/kcar
+RSYNC_DEST := yhbt.net:/srv/bogomips/kcar
 RAGEL = ragel
 RLFLAGS = -G2
 rfpackage := kcar

data/HACKING

@@ -0,0 +1,36 @@
+== development dependencies
+
+* GNU make - https://www.gnu.org/software/make/
+* git - https://www.git-scm.com/
+* ruby - https://www.ruby-lang.org/en/
+
+	git clone https://yhbt.net/kcar.git
+
+== tests
+
+* make test - run each test in a separate process (parallelize using -j)
+
+For non-GNU users, GNU make may be installed as "gmake".
+
+== test environment
+
+RUBY - specify an alternative ruby(1) runtime
+V - set to 1 for verbose test output (may be mangled if multithreaded)
+
+== installing from git
+
+* make install-gem
+
+== contact
+
+We use git(7) and develop kcar on a public mailing list like git.git
+developers do.  Please send patches via git-send-email(1) to the public
+mailing list at <mailto:kcar-public@yhbt.net>.  Pull requests should be
+formatted using git-request-pull(1).
+
+All mail is archived publically at: https://yhbt.net/kcar-public/
+and nntp://news.public-inbox.org/inbox.comp.lang.ruby.kcar
+
+Anonymous contributions will always be welcome.
+No subscription is necessary to post to the mailing list.
+Please remember to Cc: all recipients as subscription is optional.

data/LICENSE

@@ -1,7 +1,7 @@
 kcar is copyrighted free software by all contributors, see logs in
 revision control for names and email addresses of all of them.  You can
 redistribute it and/or modify it under either the terms of the
-{GPLv2}[http://www.gnu.org/licenses/gpl-2.0.txt] or later or
+{GPLv2}[https://www.gnu.org/licenses/gpl-2.0.txt] or later or
 the conditions below:
 
   1. You may make and give away verbatim copies of the source form of the

data/README

@@ -7,7 +7,7 @@ regular files, FIFOs, StringIOs as well as traditional TCP sockets.
 
 == Features
 
-* RFC2616-compliant Ragel+C parser adapted from Unicorn and Mongrel
+* RFC2616-compliant Ragel+C parser adapted from Mongrel
 
 * decodes chunked response bodies with an optional pass-through mode
   (to avoid rechunking with Rack::Chunked)
@@ -35,7 +35,7 @@ If you use RubyGems:
 
 Otherwise grab the latest tarball from:
 
-http://bogomips.org/kcar/files/
+https://yhbt.net/kcar/files/
 
 Unpack it, and run "ruby setup.rb"
 
@@ -62,14 +62,14 @@ through the body with body.each.
 
 You can get the latest source via git from the following locations:
 
-  git://bogomips.org/kcar.git
-  git://repo.or.cz/kcar.git (mirror)
+  https://yhbt.net/kcar.git
+  https://repo.or.cz/kcar.git (mirror)
 
 You may browse the code from the web and download the latest snapshot
 tarballs here:
 
-* http://bogomips.org/cgit/kcar.git (cgit)
-* http://repo.or.cz/w/kcar.git (gitweb)
+* https://yhbt.net/kcar.git
+* https://repo.or.cz/w/kcar.git (gitweb)
 
 Inline patches (from "git format-patch") to the mailing list are
 preferred because they allow code review and comments in the reply to
@@ -83,8 +83,17 @@ don't email the git mailing list or maintainer with kcar patches.
 == Contact
 
 All feedback (bug reports, user/development discussion, patches, pull
-requests) go to the mailing list: mailto:kcar-public@bogomips.org
+requests) go to the public mailing list: mailto:kcar-public@yhbt.net
+All mail is archived publically at: https://yhbt.net/kcar-public/
+and nntp://news.public-inbox.org/inbox.comp.lang.ruby.kcar
 
-Mailing list archives are available here:
+Anonymous posts will always be welcome.
 
-http://bogomips.org/kcar-public/
+No subscription is necessary to post to the mailing list;
+but you may subscribe by sending a plain-text mail to:
+
+	mailto:kcar-public+subscribe@yhbt.net
+
+Keep in mind we suck at delivering email, so using NNTP or
+Atom feeds might be a better bet.
+Please remember to Cc: all recipients as subscription is optional.

data/archive/slrnpull.conf

@@ -1,4 +1,7 @@
+# This config was used to create the import used to migrate
+# mailing list archives from gmane to https://yhbt.net/kcar-public/
+
 # group_name                         max        expire     headers_only
 gmane.comp.lang.ruby.kcar.general 1000000000 1000000000 0
 
-# usage: slrnpull -d $PWD -h news.gmane.org --no-post
+# usage: slrnpull -d $PWD -h news.gmane.io --no-post

data/ext/kcar/c_util.h

@@ -1,6 +1,6 @@
 /*
  * Generic C functions and macros go here, there are no dependencies
- * on Unicorn internal structures or the Ruby C API in here.
+ * on kcar internal structures or the Ruby C API in here.
  */
 
 #ifndef UH_util_h
@@ -49,7 +49,7 @@ static int hexchar2int(int xdigit)
   if (xdigit >= 'a' && xdigit <= 'f')
     return xdigit - 'a' + 10;
 
-  /* Ragel already does runtime range checking for us in Unicorn: */
+  /* Ragel already does runtime range checking for us */
   assert(xdigit >= '0' && xdigit <= '9' && "invalid digit character");
 
   return xdigit - '0';

data/ext/kcar/ext_help.h

@@ -1,26 +1,6 @@
 #ifndef ext_help_h
 #define ext_help_h
 
-#ifndef RSTRING_PTR
-#define RSTRING_PTR(s) (RSTRING(s)->ptr)
-#endif /* !defined(RSTRING_PTR) */
-#ifndef RSTRING_LEN
-#define RSTRING_LEN(s) (RSTRING(s)->len)
-#endif /* !defined(RSTRING_LEN) */
-
-#ifndef HAVE_RB_STR_SET_LEN
-#  ifdef RUBINIUS
-#    error we should never get here with current Rubinius (1.x)
-#  endif
-/* this is taken from Ruby 1.8.7, 1.8.6 may not have it */
-static void rb_18_str_set_len(VALUE str, long len)
-{
-  RSTRING(str)->len = len;
-  RSTRING(str)->ptr[len] = '\0';
-}
-# define rb_str_set_len(str,len) rb_18_str_set_len(str,len)
-#endif /* !defined(HAVE_RB_STR_SET_LEN) */
-
 /* not all Ruby implementations support frozen objects (Rubinius does not) */
 #if defined(OBJ_FROZEN)
 #  define assert_frozen(f) assert(OBJ_FROZEN(f) && "unfrozen object")
@@ -36,10 +16,6 @@ static void rb_18_str_set_len(VALUE str, long len)
 #  endif
 #endif /* ! defined(OFFT2NUM) */
 
-#ifndef HAVE_RB_STR_MODIFY
-#  define rb_str_modify(x) do {} while (0)
-#endif /* ! defined(HAVE_RB_STR_MODIFY) */
-
 static inline int str_cstr_eq(VALUE val, const char *ptr, long len)
 {
   return (RSTRING_LEN(val) == len && !memcmp(ptr, RSTRING_PTR(val), len));

data/ext/kcar/extconf.rb

@@ -5,10 +5,35 @@ dir_config("kcar")
 
 have_macro("SIZEOF_OFF_T", "ruby.h") or check_sizeof("off_t", "sys/types.h")
 have_macro("SIZEOF_LONG", "ruby.h") or check_sizeof("long", "sys/types.h")
-have_func("rb_str_set_len", "ruby.h")
-have_func("rb_str_modify", "ruby.h")
 
-# -fPIC is needed for Rubinius, MRI already uses it regardless
-with_cflags($CFLAGS + " -fPIC ") do
-  create_makefile("kcar_ext")
+message('checking if String#-@ (str_uminus) dedupes... ')
+begin
+  a = -(%w(t e s t).join)
+  b = -(%w(t e s t).join)
+  if a.equal?(b)
+    $CPPFLAGS += " -DSTR_UMINUS_DEDUPE=1 "
+    message("yes\n")
+  else
+    $CPPFLAGS += " -DSTR_UMINUS_DEDUPE=0 "
+    message("no, needs Ruby 2.5+\n")
+  end
+rescue NoMethodError
+  $CPPFLAGS += " -DSTR_UMINUS_DEDUPE=0 "
+  message("no, String#-@ not available\n")
 end
+
+message('checking if Hash#[]= (rb_hash_aset) dedupes... ')
+h = {}
+x = {}
+r = rand.to_s
+h[%W(#{r}).join('')] = :foo
+x[%W(#{r}).join('')] = :foo
+if x.keys[0].equal?(h.keys[0])
+  $CPPFLAGS += ' -DHASH_ASET_DEDUPE=1 '
+  message("yes\n")
+else
+  $CPPFLAGS += ' -DHASH_ASET_DEDUPE=0 '
+  message("no, needs Ruby 2.6+\n")
+end
+
+create_makefile("kcar_ext")

data/ext/kcar/kcar.rl

@@ -10,10 +10,20 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
+#include <limits.h>
 #include "c_util.h"
 
 static VALUE eParserError;
-static ID id_sq, id_sq_set;
+static ID id_uminus, id_sq, id_sq_set;
+static VALUE g_rack_url_scheme,
+  g_80, g_443, g_http, g_https,
+  g_HTTP_HOST, g_HTTP_CONNECTION, g_HTTP_TRAILER, g_HTTP_TRANSFER_ENCODING,
+  g_HTTP_VERSION,
+  g_CONTENT_LENGTH, g_CONTENT_TYPE, g_FRAGMENT,
+  g_PATH_INFO, g_QUERY_STRING,
+  g_REQUEST_METHOD, g_REQUEST_PATH, g_REQUEST_URI,
+  g_SERVER_NAME, g_SERVER_PORT, g_SERVER_PROTOCOL;
+static VALUE e413, e414;
 
 /** Defines common length and error messages for input length validation. */
 #define DEF_MAX_LENGTH(N, length) \
@@ -30,58 +40,104 @@ static ID id_sq, id_sq_set;
     rb_raise(eParserError, MAX_##N##_LENGTH_ERR); \
 } while (0)
 
+#define VALIDATE_MAX_URI_LENGTH(len, N) do { \
+  if (len > MAX_##N##_LENGTH) \
+    rb_raise(e414, MAX_##N##_LENGTH_ERR); \
+} while (0)
+
 /* Defines the maximum allowed lengths for various input elements.*/
 DEF_MAX_LENGTH(FIELD_NAME, 256);
 DEF_MAX_LENGTH(FIELD_VALUE, 80 * 1024);
 DEF_MAX_LENGTH(HEADER, (1024 * (80 + 32)));
-
-#define UH_FL_CHUNKED  0x1
-#define UH_FL_HASBODY  0x2
-#define UH_FL_INBODY   0x4
-#define UH_FL_HASTRAILER   0x8
-#define UH_FL_INTRAILER 0x10
-#define UH_FL_INCHUNK  0x20
-#define UH_FL_KEEPALIVE 0x40
-#define UH_FL_HASHEADER 0x80
+DEF_MAX_LENGTH(REQUEST_URI, 1024 * 15);
+DEF_MAX_LENGTH(REQUEST_PATH, 4096); /* common PATH_MAX on modern systems */
+DEF_MAX_LENGTH(QUERY_STRING, (1024 * 10));
 
 struct http_parser {
   int cs; /* Ragel internal state */
-  unsigned int flags;
-  size_t mark;
-  size_t offset;
+  unsigned int is_request:1;
+  unsigned int has_query:1;
+  unsigned int has_scheme:1;
+  unsigned int chunked:1;
+  unsigned int has_body:1;
+  unsigned int in_body:1;
+  unsigned int has_trailer:1;
+  unsigned int in_trailer:1;
+  unsigned int in_chunk:1;
+  unsigned int persistent:1;
+  unsigned int has_header:1;
+  unsigned int body_eof_seen:1;
+  unsigned int is_https:1;
+  unsigned int padding:19;
+  unsigned int mark;
+  unsigned int offset;
   union { /* these 2 fields don't nest */
-    size_t field;
-    size_t query;
+    unsigned int field;
+    unsigned int query;
   } start;
   union {
-    size_t field_len; /* only used during header processing */
-    size_t dest_offset; /* only used during body processing */
+    unsigned int field_len; /* only used during header processing */
+    unsigned int dest_offset; /* only used during body processing */
   } s;
   VALUE cont; /* Qfalse: unset, Qnil: ignored header, T_STRING: append */
-  VALUE status; /* String or Qnil */
+  union {
+    /* String or Qnil */
+    VALUE status; /* status string for responses */
+    VALUE host; /* Host: header for requests */
+  } v;
   union {
     off_t content;
     off_t chunk;
   } len;
 };
 
+static unsigned int ulong2uint(unsigned long n)
+{
+  unsigned int i = (unsigned int)n;
+
+  if (sizeof(unsigned int) != sizeof(unsigned long)) {
+    if ((unsigned long)i != n) {
+      rb_raise(rb_eRangeError, "too large to be 32-bit uint: %lu", n);
+    }
+  }
+  return i;
+}
+
 #define REMAINING (unsigned long)(pe - p)
-#define LEN(AT, FPC) (FPC - buffer - hp->AT)
-#define MARK(M,FPC) (hp->M = (FPC) - buffer)
+#define LEN(AT, FPC) (ulong2uint(FPC - buffer) - hp->AT)
+#define MARK(M,FPC) (hp->M = ulong2uint((FPC) - buffer))
 #define PTR_TO(F) (buffer + hp->F)
 #define STR_NEW(M,FPC) rb_str_new(PTR_TO(M), LEN(M, FPC))
 #define STRIPPED_STR_NEW(M,FPC) stripped_str_new(PTR_TO(M), LEN(M, FPC))
 
-#define HP_FL_TEST(hp,fl) ((hp)->flags & (UH_FL_##fl))
-#define HP_FL_SET(hp,fl) ((hp)->flags |= (UH_FL_##fl))
-#define HP_FL_UNSET(hp,fl) ((hp)->flags &= ~(UH_FL_##fl))
-#define HP_FL_ALL(hp,fl) (HP_FL_TEST(hp, fl) == (UH_FL_##fl))
+/* Downcases a single ASCII character.  Locale-agnostic. */
+static void downcase_char(char *c)
+{
+  if (*c >= 'A' && *c <= 'Z')
+    *c |= 0x20;
+}
 
 static int is_lws(char c)
 {
   return (c == ' ' || c == '\t');
 }
 
+/* this will dedupe under Ruby 2.5+ (December 2017) */
+static VALUE str_dd_freeze(VALUE str)
+{
+  if (STR_UMINUS_DEDUPE)
+    return rb_funcall(str, id_uminus, 0);
+
+  /* freeze,since it speeds up MRI slightly */
+  OBJ_FREEZE(str);
+  return str;
+}
+
+static VALUE str_new_dd_freeze(const char *ptr, long len)
+{
+  return str_dd_freeze(rb_str_new(ptr, len));
+}
+
 static VALUE stripped_str_new(const char *str, long len)
 {
   long end;
@@ -91,10 +147,69 @@ static VALUE stripped_str_new(const char *str, long len)
   return rb_str_new(str, end + 1);
 }
 
-static void finalize_header(struct http_parser *hp)
+static VALUE request_host_val(struct http_parser *hp)
+{
+  assert(hp->is_request == 1 && "not a request");
+  return NIL_P(hp->v.host) ? Qfalse : hp->v.host;
+}
+
+static void set_server_vars(struct http_parser *hp, VALUE env, VALUE host)
+{
+  char *host_ptr = RSTRING_PTR(host);
+  long host_len = RSTRING_LEN(host);
+  char *colon;
+  VALUE server_name = host;
+  VALUE server_port = hp->has_scheme ? (hp->is_https ? g_443 : g_80) : Qfalse;
+
+  if (*host_ptr == '[') { /* ipv6 address format */
+    char *rbracket = memchr(host_ptr + 1, ']', host_len - 1);
+
+    if (rbracket)
+      colon = (rbracket[1] == ':') ? rbracket + 1 : NULL;
+    else
+      colon = memchr(host_ptr + 1, ':', host_len - 1);
+  } else {
+    colon = memchr(host_ptr, ':', host_len);
+  }
+
+  if (colon) {
+    long port_start = colon - host_ptr + 1;
+    long port_len = host_len - port_start;
+
+    server_name = rb_str_substr(host, 0, colon - host_ptr);
+    server_name = str_dd_freeze(server_name);
+    if (port_len > 0) {
+      server_port = rb_str_substr(host, port_start, port_len);
+      server_port = str_dd_freeze(server_port);
+    }
+  }
+  rb_hash_aset(env, g_SERVER_NAME, server_name);
+  if (server_port != Qfalse)
+    rb_hash_aset(env, g_SERVER_PORT, server_port);
+}
+
+static void finalize_header(struct http_parser *hp, VALUE hdr)
 {
-  if ((HP_FL_TEST(hp, HASTRAILER) && ! HP_FL_TEST(hp, CHUNKED)))
+  if (hp->has_trailer && !hp->chunked)
     rb_raise(eParserError, "trailer but not chunked");
+  if (hp->is_request) {
+    if (hp->chunked) {
+      if (hp->len.chunk >= 0)
+        rb_raise(eParserError, "Content-Length set with chunked encoding");
+      else
+        hp->len.chunk = 0;
+    } else if (hp->len.content < 0) {
+        hp->len.content = 0;
+    }
+
+    if (!hp->has_query)
+      rb_hash_aset(hdr, g_QUERY_STRING, rb_str_new(NULL, 0));
+    if (hp->has_header) {
+      VALUE host = request_host_val(hp);
+      if (host != Qfalse)
+        set_server_vars(hp, hdr, host);
+    }
+  }
 }
 
 /*
@@ -107,28 +222,116 @@ static void hp_keepalive_connection(struct http_parser *hp, VALUE val)
   /* REQUEST_METHOD is always set before any headers */
   if (STR_CSTR_CASE_EQ(val, "keep-alive")) {
     /* basically have HTTP/1.0 masquerade as HTTP/1.1+ */
-    HP_FL_SET(hp, KEEPALIVE);
+    hp->persistent = 1;
   } else if (STR_CSTR_CASE_EQ(val, "close")) {
     /*
      * it doesn't matter what HTTP version or request method we have,
      * if a server says "Connection: close", we disable keepalive
      */
-    HP_FL_UNSET(hp, KEEPALIVE);
+    hp->persistent = 0;
   } else {
     /*
      * server could've sent anything, ignore it for now.  Maybe
-     * "HP_FL_UNSET(hp, KEEPALIVE);" just in case?
+     * "hp->persistent = 0;" just in case?
      * Raising an exception might be too mean...
      */
   }
 }
 
 static void
-http_version(struct http_parser *hp, VALUE hdr, const char *ptr, size_t len)
+request_method(VALUE env, const char *ptr, size_t len)
+{
+  rb_hash_aset(env, g_REQUEST_METHOD, str_new_dd_freeze(ptr, len));
+}
+
+static void
+url_scheme(struct http_parser *hp, VALUE env, const char *ptr, size_t len)
+{
+  VALUE val;
+
+  hp->has_scheme = 1;
+  /* Ragel machine downcases and enforces this as "http" or "https" */
+  if (len == 5) {
+    hp->is_https = 1;
+    assert(CONST_MEM_EQ("https", ptr, len) && "len == 5 but not 'https'");
+    val = g_https;
+  } else {
+    assert(CONST_MEM_EQ("http", ptr, len) && "len != 4 but not 'http'");
+    val = g_http;
+  }
+  rb_hash_aset(env, g_rack_url_scheme, val);
+}
+
+static void
+request_host(struct http_parser *hp, VALUE env, const char *ptr, size_t len)
+{
+  VALUE val = rb_str_new(ptr, len);
+
+  rb_hash_aset(env, g_HTTP_HOST, val);
+  hp->v.host = val;
+}
+
+static void
+set_fragment(VALUE env, const char *ptr, size_t len)
+{
+  VALUE val = rb_str_new(ptr, len);
+  rb_hash_aset(env, g_FRAGMENT, val);
+}
+
+static void
+request_uri(VALUE env, const char *ptr, size_t len)
+{
+  VALUE val;
+
+  VALIDATE_MAX_URI_LENGTH(len, REQUEST_URI);
+  val = rb_str_new(ptr, len);
+  rb_hash_aset(env, g_REQUEST_URI, val);
+
+  /*
+   * rack says PATH_INFO must start with "/" or be empty,
+   * but "OPTIONS *" is a valid request
+   */
+  if (CONST_MEM_EQ("*", ptr, len)) {
+    val = rb_str_new(NULL, 0);
+    rb_hash_aset(env, g_PATH_INFO, val);
+    rb_hash_aset(env, g_REQUEST_PATH, val);
+  }
+}
+
+static void
+query_string(struct http_parser *hp, VALUE env, const char *ptr, size_t len)
+{
+  VALIDATE_MAX_URI_LENGTH(len, QUERY_STRING);
+
+  hp->has_query = 1;
+  rb_hash_aset(env, g_QUERY_STRING, rb_str_new(ptr, len));
+}
+
+static void
+request_path(VALUE env, const char *ptr, size_t len)
+{
+  VALUE val;
+
+  VALIDATE_MAX_URI_LENGTH(len, REQUEST_PATH);
+  val = rb_str_new(ptr, len);
+
+  rb_hash_aset(env, g_REQUEST_PATH, val);
+  rb_hash_aset(env, g_PATH_INFO, val);
+}
+
+static void
+http_version(struct http_parser *hp, VALUE env, const char *ptr, size_t len)
 {
   if (CONST_MEM_EQ("HTTP/1.1", ptr, len)) {
     /* HTTP/1.1 implies keepalive unless "Connection: close" is set */
-    HP_FL_SET(hp, KEEPALIVE);
+    hp->persistent = 1;
+  }
+  if (hp->is_request) {
+    VALUE v = str_new_dd_freeze(ptr, len);
+    hp->has_header = 1;
+
+    rb_hash_aset(env, g_SERVER_PROTOCOL, v);
+    rb_hash_aset(env, g_HTTP_VERSION, v);
   }
 }
 
@@ -137,21 +340,21 @@ status_phrase(struct http_parser *hp, VALUE hdr, const char *ptr, size_t len)
 {
   long nr;
 
-  hp->status = rb_str_new(ptr, len);
+  hp->v.status = str_new_dd_freeze(ptr, len);
 
   /* RSTRING_PTR is null terminated, ptr is not */
-  nr = strtol(RSTRING_PTR(hp->status), NULL, 10);
+  nr = strtol(RSTRING_PTR(hp->v.status), NULL, 10);
 
   if (nr < 100 || nr > 999)
-    rb_raise(eParserError, "invalid status: %s", RSTRING_PTR(hp->status));
+    rb_raise(eParserError, "invalid status: %s", RSTRING_PTR(hp->v.status));
 
   if ( !((nr >= 100 && nr <= 199) || nr == 204 || nr == 304) )
-    HP_FL_SET(hp, HASBODY);
+    hp->has_body = 1;
 }
 
 static inline void invalid_if_trailer(struct http_parser *hp)
 {
-  if (HP_FL_TEST(hp, INTRAILER))
+  if (hp->in_trailer)
     rb_raise(eParserError, "invalid Trailer");
 }
 
@@ -185,15 +388,15 @@ static void write_cont_value(struct http_parser *hp,
 
   /* normalize tab to space */
   if (cont_len > 0) {
-    assert((' ' == *vptr || '\t' == *vptr) && "invalid leading white space");
+    assert(is_lws(*vptr) && "invalid leading white space");
     *vptr = ' ';
   }
   for (end = len - 1; end >= 0 && is_lws(vptr[end]); end--);
   rb_str_buf_cat(hp->cont, vptr, end + 1);
 }
 
-static void write_value(VALUE hdr, struct http_parser *hp,
-                        const char *buffer, const char *p)
+static void write_response_value(struct http_parser *hp, VALUE hdr,
+                          const char *buffer, const char *p)
 {
   VALUE f, v;
   VALUE hclass;
@@ -202,7 +405,7 @@ static void write_value(VALUE hdr, struct http_parser *hp,
   const char *vptr;
   size_t vlen;
 
-  HP_FL_SET(hp, HASHEADER);
+  hp->has_header = 1;
 
   /* Rack does not like Status headers, so we never send them */
   if (CSTR_CASE_EQ(fptr, flen, "status")) {
@@ -214,7 +417,7 @@ static void write_value(VALUE hdr, struct http_parser *hp,
   vlen = LEN(mark, p);
   VALIDATE_MAX_LENGTH(vlen, FIELD_VALUE);
   VALIDATE_MAX_LENGTH(flen, FIELD_NAME);
-  f = rb_str_new(fptr, (long)flen);
+  f = str_new_dd_freeze(fptr, (long)flen);
   v = stripped_str_new(vptr, (long)vlen);
 
   /* needs more tests for error-checking here */
@@ -226,9 +429,9 @@ static void write_value(VALUE hdr, struct http_parser *hp,
   if (STR_CSTR_CASE_EQ(f, "connection")) {
     hp_keepalive_connection(hp, v);
   } else if (STR_CSTR_CASE_EQ(f, "content-length")) {
-    if (! HP_FL_TEST(hp, HASBODY))
+    if (!hp->has_body)
       rb_raise(eParserError, "Content-Length with no body expected");
-    if (HP_FL_TEST(hp, CHUNKED))
+    if (hp->chunked)
       rb_raise(eParserError,
                "Content-Length when chunked Transfer-Encoding is set");
     hp->len.content = parse_length(vptr, vlen);
@@ -239,7 +442,7 @@ static void write_value(VALUE hdr, struct http_parser *hp,
     invalid_if_trailer(hp);
   } else if (STR_CSTR_CASE_EQ(f, "transfer-encoding")) {
     if (STR_CSTR_CASE_EQ(v, "chunked")) {
-      if (! HP_FL_TEST(hp, HASBODY))
+      if (!hp->has_body)
         rb_raise(eParserError,
                  "chunked Transfer-Encoding with no body expected");
       if (hp->len.content >= 0)
@@ -247,13 +450,13 @@ static void write_value(VALUE hdr, struct http_parser *hp,
                  "chunked Transfer-Encoding when Content-Length is set");
 
       hp->len.chunk = 0;
-      HP_FL_SET(hp, CHUNKED);
+      hp->chunked = 1;
     }
     invalid_if_trailer(hp);
   } else if (STR_CSTR_CASE_EQ(f, "trailer")) {
-    if (! HP_FL_TEST(hp, HASBODY))
+    if (!hp->has_body)
       rb_raise(eParserError, "trailer with no body");
-    HP_FL_SET(hp, HASTRAILER);
+    hp->has_trailer = 1;
     invalid_if_trailer(hp);
   }
 
@@ -272,9 +475,6 @@ static void write_value(VALUE hdr, struct http_parser *hp,
       e = rb_funcall(hdr, id_sq, 1, f);
 
     if (NIL_P(e)) {
-      /* new value, freeze it since it speeds up MRI slightly */
-      OBJ_FREEZE(f);
-
       if (hclass == rb_cHash)
         rb_hash_aset(hdr, f, v);
       else
@@ -295,6 +495,112 @@ static void write_value(VALUE hdr, struct http_parser *hp,
   }
 }
 
+static VALUE req_field(const char *ptr, size_t len)
+{
+  size_t pfxlen = sizeof("HTTP_") - 1;
+  VALUE str = rb_str_new(NULL, pfxlen + len);
+  char *dst = RSTRING_PTR(str);
+
+  memcpy(dst, "HTTP_", pfxlen);
+  memcpy(dst + pfxlen, ptr, len);
+  assert(*(dst + RSTRING_LEN(str)) == '\0' &&
+         "string didn't end with \\0"); /* paranoia */
+
+  return str;
+}
+
+static void snake_upcase(char *ptr, size_t len)
+{
+  char *c;
+
+  for (c = ptr; len--; c++) {
+    if (*c >= 'a' && *c <= 'z')
+      *c &= ~0x20;
+    else if (*c == '-')
+      *c = '_';
+  }
+}
+
+static void write_request_value(struct http_parser *hp, VALUE env,
+                            char *buffer, const char *p)
+{
+  char *fptr = PTR_TO(start.field);
+  size_t flen = hp->s.field_len;
+  char *vptr = PTR_TO(mark);
+  size_t vlen = LEN(mark, p);
+  VALUE key, val;
+  VALUE existing;
+
+  VALIDATE_MAX_LENGTH(flen, FIELD_NAME);
+  VALIDATE_MAX_LENGTH(LEN(mark, p), FIELD_VALUE);
+  snake_upcase(fptr, flen);
+
+  /*
+   * ignore "Version" headers since they conflict with the HTTP_VERSION
+   * rack env variable.
+   */
+  if (CONST_MEM_EQ("VERSION", fptr, flen)) {
+    hp->cont = Qnil;
+    return;
+  }
+  val = vlen == 0 ? rb_str_new(0, 0) : stripped_str_new(vptr, vlen);
+
+  if (CONST_MEM_EQ("CONNECTION", fptr, flen)) {
+    key = g_HTTP_CONNECTION;
+    hp_keepalive_connection(hp, val);
+  } else if (CONST_MEM_EQ("CONTENT_LENGTH", fptr, flen)) {
+    key = g_CONTENT_LENGTH;
+    hp->len.content = parse_length(vptr, vlen);
+    if (hp->len.content < 0)
+      rb_raise(eParserError, "invalid Content-Length");
+    if (hp->len.content != 0)
+      hp->has_body = 1;
+    invalid_if_trailer(hp);
+  } else if (CONST_MEM_EQ("CONTENT_TYPE", fptr, flen)) {
+    key = g_CONTENT_TYPE;
+  } else if (CONST_MEM_EQ("TRANSFER_ENCODING", fptr, flen)) {
+    key = g_HTTP_TRANSFER_ENCODING;
+    if (STR_CSTR_CASE_EQ(val, "chunked")) {
+      hp->chunked = 1;
+      hp->has_body = 1;
+    }
+    invalid_if_trailer(hp);
+  } else if (CONST_MEM_EQ("TRAILER", fptr, flen)) {
+    key = g_HTTP_TRAILER;
+    hp->has_trailer = 1;
+    invalid_if_trailer(hp);
+  } else if (CONST_MEM_EQ("HOST", fptr, flen)) {
+    key = g_HTTP_HOST;
+    if (NIL_P(hp->v.host))
+      hp->v.host = val;
+  } else {
+    key = req_field(fptr, flen);
+    if (!HASH_ASET_DEDUPE)
+      key = str_dd_freeze(key);
+  }
+  existing = rb_hash_aref(env, key);
+  if (NIL_P(existing)) {
+    hp->cont = rb_hash_aset(env, key, val);
+  /*
+   * Ignore repeated Host headers and favor host set by absolute URIs.
+   * absoluteURI Request-URI takes precedence over
+   * the Host: header (ref: rfc 2616, section 5.2.1)
+   */
+  } else if (key == g_HTTP_HOST) {
+     hp->cont = Qnil;
+  } else {
+    rb_str_buf_cat(existing, ",", 1);
+    hp->cont = rb_str_buf_append(existing, val);
+  }
+}
+
+static void write_value(struct http_parser *hp, VALUE hdr,
+                        char *buf, const char *p)
+{
+  hp->is_request ? write_request_value(hp, hdr, buf, p) :
+                   write_response_value(hp, hdr, buf, p);
+}
+
 /** Machine **/
 
 %%{
@@ -302,10 +608,22 @@ static void write_value(VALUE hdr, struct http_parser *hp,
 
   action mark {MARK(mark, fpc); }
 
+  action snake_upcase_field { snake_upcase_char(deconst(fpc)); }
+  action downcase_char { downcase_char(deconst(fpc)); }
+  action request_method { request_method(hdr, PTR_TO(mark), LEN(mark, fpc)); }
+  action url_scheme { url_scheme(hp, hdr, PTR_TO(mark), LEN(mark, fpc)); }
+  action host { request_host(hp, hdr, PTR_TO(mark), LEN(mark, fpc)); }
+  action request_uri { request_uri(hdr, PTR_TO(mark), LEN(mark, fpc)); }
+  action fragment { set_fragment(hdr, PTR_TO(mark), LEN(mark, fpc)); }
+  action start_query { MARK(start.query, fpc); }
+  action query_string {
+    query_string(hp, hdr, PTR_TO(start.query), LEN(start.query, fpc));
+  }
+  action request_path { request_path(hdr, PTR_TO(mark), LEN(mark, fpc)); }
   action start_field { MARK(start.field, fpc); }
   action write_field { hp->s.field_len = LEN(start.field, fpc); }
   action start_value { MARK(mark, fpc); }
-  action write_value { write_value(hdr, hp, buffer, fpc); }
+  action write_value { write_value(hp, hdr, buffer, fpc); }
   action write_cont_value { write_cont_value(hp, buffer, fpc); }
   action http_version { http_version(hp, hdr, PTR_TO(mark), LEN(mark, fpc)); }
   action status_phrase { status_phrase(hp, hdr, PTR_TO(mark), LEN(mark, fpc)); }
@@ -316,10 +634,10 @@ static void write_value(VALUE hdr, struct http_parser *hp,
       rb_raise(eParserError, "invalid chunk size");
   }
   action header_done {
-    finalize_header(hp);
+    finalize_header(hp, hdr);
     cs = http_parser_first_final;
 
-    if (HP_FL_TEST(hp, CHUNKED))
+    if (hp->chunked)
       cs = http_parser_en_ChunkedBody;
 
     /*
@@ -335,7 +653,7 @@ static void write_value(VALUE hdr, struct http_parser *hp,
   }
 
   action end_chunked_body {
-    HP_FL_SET(hp, INTRAILER);
+    hp->in_trailer = 1;
     cs = http_parser_en_Trailers;
     ++p;
     assert(p <= pe && "buffer overflow after chunked body");
@@ -351,7 +669,7 @@ static void write_value(VALUE hdr, struct http_parser *hp,
     p += nr;
     assert(hp->len.chunk >= 0 && "negative chunk length");
     if ((size_t)hp->len.chunk > REMAINING) {
-      HP_FL_SET(hp, INCHUNK);
+      hp->in_chunk = 1;
       goto post_exec;
     } else {
       fhold;
@@ -370,7 +688,7 @@ static void http_parser_init(struct http_parser *hp)
   int cs = 0;
   memset(hp, 0, sizeof(struct http_parser));
   hp->cont = Qfalse; /* zero on MRI, should be optimized away by above */
-  hp->status = Qnil;
+  hp->v.status = Qnil;
   hp->len.content = -1;
   %% write init;
   hp->cs = cs;
@@ -395,43 +713,55 @@ static void http_parser_execute(struct http_parser *hp,
   assert((void *)(pe - p) == (void *)(len - off) &&
          "pointers aren't same distance");
 
-  if (HP_FL_TEST(hp, INCHUNK)) {
-    HP_FL_UNSET(hp, INCHUNK);
+  if (hp->in_chunk) {
+    hp->in_chunk = 0;
     goto skip_chunk_data_hack;
   }
   %% write exec;
 post_exec: /* "_out:" also goes here */
   if (hp->cs != http_parser_error)
     hp->cs = cs;
-  hp->offset = p - buffer;
+  hp->offset = ulong2uint(p - buffer);
 
   assert(p <= pe && "buffer overflow after parsing execute");
   assert(hp->offset <= len && "offset longer than length");
 }
 
-static struct http_parser *data_get(VALUE self)
+static void kcar_mark(void *ptr)
 {
-  struct http_parser *hp;
+  struct http_parser *hp = ptr;
 
-  Data_Get_Struct(self, struct http_parser, hp);
-  assert(hp && "failed to extract http_parser struct");
-  return hp;
+  rb_gc_mark(hp->cont);
+  rb_gc_mark(hp->v.status);
 }
 
-static void mark(void *ptr)
+static size_t kcar_memsize(const void *ptr)
 {
-  struct http_parser *hp = ptr;
+  return sizeof(struct http_parser);
+}
 
-  rb_gc_mark(hp->cont);
-  rb_gc_mark(hp->status);
+static const rb_data_type_t kcar_type = {
+  "kcar_parser",
+  { kcar_mark, RUBY_TYPED_DEFAULT_FREE, kcar_memsize, /* reserved */ },
+  /* parent, data, [ flags ] */
+};
+
+static VALUE kcar_alloc(VALUE klass)
+{
+  struct http_parser *hp;
+  return TypedData_Make_Struct(klass, struct http_parser, &kcar_type, hp);
 }
 
-static VALUE alloc(VALUE klass)
+static struct http_parser *data_get(VALUE self)
 {
   struct http_parser *hp;
-  return Data_Make_Struct(klass, struct http_parser, mark, -1, hp);
+
+  TypedData_Get_Struct(self, struct http_parser, &kcar_type, hp);
+  assert(hp && "failed to extract http_parser struct");
+  return hp;
 }
 
+
 /**
  * call-seq:
  *    Kcar::Parser.new => parser
@@ -485,7 +815,7 @@ static VALUE body_bytes_left(VALUE self)
 {
   struct http_parser *hp = data_get(self);
 
-  if (HP_FL_TEST(hp, CHUNKED))
+  if (hp->chunked)
     return Qnil;
   if (hp->len.content >= 0)
     return OFFT2NUM(hp->len.content);
@@ -505,9 +835,11 @@ static VALUE body_bytes_left_set(VALUE self, VALUE bytes)
 {
   struct http_parser *hp = data_get(self);
 
-  if (HP_FL_TEST(hp, CHUNKED))
+  if (hp->chunked)
     rb_raise(rb_eRuntimeError, "body_bytes_left= is not for chunked bodies");
   hp->len.content = NUM2OFFT(bytes);
+  if (hp->len.content == 0)
+      hp->body_eof_seen = 1;
   return bytes;
 }
 
@@ -522,7 +854,30 @@ static VALUE chunked(VALUE self)
 {
   struct http_parser *hp = data_get(self);
 
-  return HP_FL_TEST(hp, CHUNKED) ? Qtrue : Qfalse;
+  return hp->chunked ? Qtrue : Qfalse;
+}
+
+static void check_buffer_size(long dlen)
+{
+  if ((uint64_t)dlen > UINT_MAX)
+    rb_raise(rb_eRangeError, "headers too large to process (%ld bytes)", dlen);
+}
+
+static void parser_execute(struct http_parser *hp, VALUE hdr, VALUE buf)
+{
+  char *ptr;
+  long len;
+
+  Check_Type(buf, T_STRING);
+  rb_str_modify(buf);
+  ptr = RSTRING_PTR(buf);
+  len = RSTRING_LEN(buf);
+  check_buffer_size(len);
+
+  http_parser_execute(hp, hdr, ptr, len);
+
+  if (hp->cs == http_parser_error)
+    rb_raise(eParserError, "Invalid HTTP format, parsing fails.");
 }
 
 /**
@@ -541,28 +896,49 @@ static VALUE headers(VALUE self, VALUE hdr, VALUE data)
 {
   struct http_parser *hp = data_get(self);
 
-  http_parser_execute(hp, hdr, RSTRING_PTR(data), RSTRING_LEN(data));
+  if (hp->is_request)
+    rb_raise(rb_eRuntimeError, "parser is handling a request, not response");
+
+  parser_execute(hp, hdr, data);
   VALIDATE_MAX_LENGTH(hp->offset, HEADER);
 
   if (hp->cs == http_parser_first_final ||
       hp->cs == http_parser_en_ChunkedBody) {
     advance_str(data, hp->offset + 1);
     hp->offset = 0;
-    if (HP_FL_TEST(hp, INTRAILER))
+    if (hp->in_trailer)
       return hdr;
     else
-      return rb_ary_new3(2, hp->status, hdr);
+      return rb_ary_new3(2, hp->v.status, hdr);
   }
 
-  if (hp->cs == http_parser_error)
-    rb_raise(eParserError, "Invalid HTTP format, parsing fails.");
-
   return Qnil;
 }
 
+static VALUE request(VALUE self, VALUE env, VALUE buf)
+{
+  struct http_parser *hp = data_get(self);
+
+  hp->is_request = 1;
+  Check_Type(buf, T_STRING);
+  parser_execute(hp, env, buf);
+
+  if (hp->cs == http_parser_first_final ||
+      hp->cs == http_parser_en_ChunkedBody) {
+    advance_str(buf, hp->offset + 1);
+    hp->offset = 0;
+    if (hp->in_trailer)
+      hp->body_eof_seen = 1;
+
+    return env;
+  }
+  return Qnil; /* incomplete */
+}
+
+
 static int chunked_eof(struct http_parser *hp)
 {
-  return ((hp->cs == http_parser_first_final) || HP_FL_TEST(hp, INTRAILER));
+  return ((hp->cs == http_parser_first_final) || hp->in_trailer);
 }
 
 /**
@@ -576,13 +952,13 @@ static VALUE body_eof(VALUE self)
 {
   struct http_parser *hp = data_get(self);
 
-  if (!HP_FL_TEST(hp, HASHEADER) && HP_FL_ALL(hp, KEEPALIVE))
+  if (!hp->has_header && hp->persistent)
     return Qtrue;
 
-  if (HP_FL_TEST(hp, CHUNKED))
+  if (hp->chunked)
     return chunked_eof(hp) ? Qtrue : Qfalse;
 
-  if (! HP_FL_TEST(hp, HASBODY))
+  if (!hp->has_body)
     return Qtrue;
 
   return hp->len.content == 0 ? Qtrue : Qfalse;
@@ -604,10 +980,14 @@ static VALUE keepalive(VALUE self)
 {
   struct http_parser *hp = data_get(self);
 
-  if (HP_FL_ALL(hp, KEEPALIVE)) {
-    if (HP_FL_TEST(hp, HASHEADER) && HP_FL_TEST(hp, HASBODY) ) {
-      if (HP_FL_TEST(hp, CHUNKED) || (hp->len.content >= 0))
-        return Qtrue;
+  if (hp->persistent) {
+    if (hp->has_header && hp->has_body) {
+      if (hp->chunked || (hp->len.content >= 0)) {
+        if (!hp->is_request)
+          return Qtrue;
+        else
+          return hp->body_eof_seen ? Qtrue : Qfalse;
+      }
 
       /* unknown Content-Length and not chunked, we must assume close */
       return Qfalse;
@@ -621,54 +1001,77 @@ static VALUE keepalive(VALUE self)
 
 /**
  * call-seq:
- *    parser.filter_body(buf, data) => nil/data
+ *    parser.filter_body(dst, src) => nil/dst
  *
- * Takes a String of +data+, will modify data if dechunking is done.
- * Returns +nil+ if there is more data left to process.  Returns
- * +data+ if body processing is complete. When returning +data+,
- * it may modify +data+ so the start of the string points to where
+ * Takes a String of +src+, will modify src if dechunking is done.
+ * Returns +nil+ if there is more +src+ left to process.  Returns
+ * +dst+ if body processing is complete. When returning +dst+,
+ * it may modify +src+ so the start of the string points to where
  * the body ended so that trailer processing can begin.
  *
  * Raises ParserError if there are dechunking errors.
- * Basically this is a glorified memcpy(3) that copies +data+
- * into +buf+ while filtering it through the dechunker.
+ * Basically this is a glorified memcpy(3) that copies +src+
+ * into +dst+ while filtering it through the dechunker.
  */
-static VALUE filter_body(VALUE self, VALUE buf, VALUE data)
+static VALUE filter_body(VALUE self, VALUE dst, VALUE src)
 {
   struct http_parser *hp = data_get(self);
-  char *dptr;
-  long dlen;
+  char *sptr;
+  long slen;
 
-  dptr = RSTRING_PTR(data);
-  dlen = RSTRING_LEN(data);
+  sptr = RSTRING_PTR(src);
+  slen = RSTRING_LEN(src);
+  check_buffer_size(slen);
 
-  StringValue(buf);
-  rb_str_modify(buf);
-  rb_str_resize(buf, dlen); /* we can never copy more than dlen bytes */
-  OBJ_TAINT(buf); /* keep weirdo $SAFE users happy */
+  StringValue(dst);
+  rb_str_modify(dst);
+  OBJ_TAINT(dst); /* keep weirdo $SAFE users happy */
 
-  if (!HP_FL_TEST(hp, CHUNKED))
+  /*
+   * for now, only support filter_body for identity requests,
+   * not responses; it's rather inefficient to blindly memcpy
+   * giant request bodies; on the other hand, it simplifies
+   * server-side code.
+   */
+  if (hp->is_request && !hp->chunked) {
+    /* no need to enter the Ragel machine for unchunked transfers */
+    assert(hp->len.content >= 0 && "negative Content-Length");
+    if (hp->len.content > 0) {
+      long nr = MIN(slen, hp->len.content);
+
+      rb_str_resize(dst, nr);
+      memcpy(RSTRING_PTR(dst), sptr, nr);
+      hp->len.content -= nr;
+      if (hp->len.content == 0)
+        hp->body_eof_seen = 1;
+      advance_str(src, nr);
+    }
+    return dst;
+  }
+
+  if (!hp->chunked)
     rb_raise(rb_eRuntimeError, "filter_body is only for chunked bodies");
 
+  rb_str_resize(dst, slen); /* we can never copy more than slen bytes */
   if (!chunked_eof(hp)) {
     hp->s.dest_offset = 0;
-    http_parser_execute(hp, buf, dptr, dlen);
+    http_parser_execute(hp, dst, sptr, slen);
     if (hp->cs == http_parser_error)
       rb_raise(eParserError, "Invalid HTTP format, parsing fails.");
 
     assert(hp->s.dest_offset <= hp->offset &&
            "destination buffer overflow");
-    advance_str(data, hp->offset);
-    rb_str_set_len(buf, hp->s.dest_offset);
+    advance_str(src, hp->offset);
+    rb_str_set_len(dst, hp->s.dest_offset);
 
-    if (RSTRING_LEN(buf) == 0 && chunked_eof(hp)) {
+    if (RSTRING_LEN(dst) == 0 && chunked_eof(hp)) {
       assert(hp->len.chunk == 0 && "chunk at EOF but more to parse");
     } else {
-      data = Qnil;
+      dst = Qnil;
     }
   }
   hp->offset = 0; /* for trailer parsing */
-  return data;
+  return dst;
 }
 
 void Init_kcar_ext(void)
@@ -676,11 +1079,21 @@ void Init_kcar_ext(void)
   VALUE mKcar = rb_define_module("Kcar");
   VALUE cParser = rb_define_class_under(mKcar, "Parser", rb_cObject);
 
+  /*
+   * Document-class: Kcar::ParserError
+   *
+   * This is raised if there are parsing errors.
+   */
   eParserError = rb_define_class_under(mKcar, "ParserError", rb_eIOError);
+  e413 = rb_define_class_under(mKcar, "RequestEntityTooLargeError",
+                               eParserError);
+  e414 = rb_define_class_under(mKcar, "RequestURITooLongError",
+                               eParserError);
 
-  rb_define_alloc_func(cParser, alloc);
+  rb_define_alloc_func(cParser, kcar_alloc);
   rb_define_method(cParser, "initialize", initialize, 0);
   rb_define_method(cParser, "reset", initialize, 0);
+  rb_define_method(cParser, "request", request, 2);
   rb_define_method(cParser, "headers", headers, 2);
   rb_define_method(cParser, "trailers", headers, 2);
   rb_define_method(cParser, "filter_body", filter_body, 2);
@@ -706,4 +1119,34 @@ void Init_kcar_ext(void)
   rb_define_const(cParser, "LENGTH_MAX", OFFT2NUM(UH_OFF_T_MAX));
   id_sq = rb_intern("[]");
   id_sq_set = rb_intern("[]=");
+  id_uminus = rb_intern("-@");
+
+  /* TODO: gperf to make a perfect hash of common strings */
+#define C(var, cstr) do { \
+  var = str_new_dd_freeze((cstr), sizeof(cstr) - 1); \
+  rb_gc_register_mark_object((var)); \
+} while (0);
+
+  C(g_CONTENT_LENGTH, "CONTENT_LENGTH");
+  C(g_CONTENT_TYPE, "CONTENT_TYPE");
+  C(g_FRAGMENT, "FRAGMENT");
+  C(g_HTTP_HOST, "HTTP_HOST");
+  C(g_HTTP_CONNECTION, "HTTP_CONNECTION");
+  C(g_HTTP_TRAILER, "HTTP_TRAILER");
+  C(g_HTTP_TRANSFER_ENCODING, "HTTP_TRANSFER_ENCODING");
+  C(g_HTTP_VERSION, "HTTP_VERSION");
+  C(g_PATH_INFO, "PATH_INFO");
+  C(g_QUERY_STRING, "QUERY_STRING");
+  C(g_REQUEST_METHOD, "REQUEST_METHOD");
+  C(g_REQUEST_PATH, "REQUEST_PATH");
+  C(g_REQUEST_URI, "REQUEST_URI");
+  C(g_SERVER_NAME, "SERVER_NAME");
+  C(g_SERVER_PORT, "SERVER_PORT");
+  C(g_SERVER_PROTOCOL, "SERVER_PROTOCOL");
+  C(g_rack_url_scheme, "rack.url_scheme");
+  C(g_http, "http");
+  C(g_https, "https");
+  C(g_80, "80");
+  C(g_443, "443");
+#undef C
 }