kcar 0.6.0 → 0.7.0

data/ext/kcar/kcar_http_common.rl

@@ -21,20 +21,49 @@
   pchar = (uchar | ":" | "@" | "&" | "=" | "+");
   tspecials = ("(" | ")" | "<" | ">" | "@" | "," | ";" | ":" | "\\" | "\"" | "/" | "[" | "]" | "?" | "=" | "{" | "}" | " " | "\t");
   lws = (" " | "\t");
+  content = ((any -- CTL) | lws);
 
 # elements
   token = (ascii -- (CTL | tspecials));
+
+# URI schemes and absolute paths
+  scheme = ( "http"i ("s"i)? ) $downcase_char >mark %url_scheme;
+  hostname = ((alnum | "-" | "." | "_")+ | ("[" (":" | xdigit)+ "]"));
+  host_with_port = (hostname (":" digit*)?) >mark %host;
+  userinfo = ((unreserved | escape | ";" | ":" | "&" | "=" | "+")+ "@")*;
+
+  path = ( pchar+ ( "/" pchar* )* ) ;
+  query = ( uchar | reserved )* %query_string ;
+  param = ( pchar | "/" )* ;
+  params = ( param ( ";" param )* ) ;
+  rel_path = (path? (";" params)? %request_path) ("?" %start_query query)?;
+  absolute_path = ( "/"+ rel_path );
+  path_uri = absolute_path > mark %request_uri;
+  Absolute_URI = (scheme "://" userinfo host_with_port path_uri);
+
+  Request_URI = ((absolute_path | "*") >mark %request_uri) | Absolute_URI;
+
+  # lets not waste cycles setting fragment in the request,
+  # valid clients do not send it, but we will just silently ignore it.
+  Fragment = ( uchar | reserved )* >mark %fragment;
+
+  Method = (token){1,20} >mark %request_method;
+  GetOnly = "GET" >mark %request_method;
+
+  http_number = ( digit+ "." digit+ ) ;
+  HTTP_Version = ( "HTTP/" http_number ) >mark %http_version ;
+  Request_Line = ( Method " " Request_URI ("#" Fragment){0,1} " "
+                   HTTP_Version CRLF ) ;
+
   phrase = (any -- CRLF)+;
   Status_Phrase = (digit+ (" "+ phrase)?) >mark %status_phrase ;
-  http_number = (digit+ "." digit+) ;
-  HTTP_Version = ("HTTP/" http_number) >mark %http_version ;
   Status_Line = HTTP_Version " "+ Status_Phrase :> CRLF;
 
   field_name = ( token -- ":" )+ >start_field %write_field;
 
-  field_value = any* >start_value %write_value;
+  field_value = content* >start_value %write_value;
 
-  value_cont = lws+ any* >start_value %write_cont_value;
+  value_cont = lws+ content* >start_value %write_cont_value;
 
   message_header = ((field_name ":" lws* field_value)|value_cont) :> CRLF;
   chunk_ext_val = token*;
@@ -50,7 +79,9 @@
   Trailers := (message_header)* CRLF @end_trailers;
 
   FullResponse = Status_Line (message_header)* CRLF @header_done;
+  FullRequest = Request_Line (message_header)* CRLF @header_done;
+  SimpleRequest = GetOnly " " Request_URI ("#"Fragment){0,1} CRLF @header_done;
 
-main := FullResponse;
+main := FullResponse | FullRequest | SimpleRequest;
 
 }%%

data/kcar.gemspec

@@ -1,23 +1,27 @@
-ENV["VERSION"] or abort "VERSION= must be specified"
-manifest = File.readlines('.manifest').map! { |x| x.chomp! }
-require 'olddoc'
-extend Olddoc::Gemspec
-name, summary, title = readme_metadata
+manifest = File.exist?('.manifest') ?
+  IO.readlines('.manifest').map!(&:chomp!) : `git ls-files`.split("\n")
 
 Gem::Specification.new do |s|
   s.name = %q{kcar}
-  s.version = ENV["VERSION"].dup
-  s.homepage = Olddoc.config['rdoc_url']
+  s.version = (ENV['VERSION'] || '0.7.0').dup
+  s.homepage = 'https://yhbt.net/kcar/'
   s.authors = ["kcar hackers"]
-  s.description = readme_description
-  s.email = %q{kcar@bogomips.org}
-  s.extra_rdoc_files = extra_rdoc_files(manifest)
+  s.description = File.read('README').split("\n\n")[1]
+  s.email = %q{kcar-public@yhbt.net}
+  s.extra_rdoc_files = IO.readlines('.document').map!(&:chomp!).keep_if do |f|
+    File.exist?(f)
+  end
   s.files = manifest
-  s.summary = summary
+  s.summary = 'bytestream to Rack response converter'
   s.test_files = Dir['test/test_*.rb']
   s.extensions = %w(ext/kcar/extconf.rb)
-  s.add_development_dependency('olddoc', '~> 1.0')
   s.add_development_dependency('test-unit', '~> 3.0')
 
-  s.licenses = %w(GPLv2+ Ruby)
+  # Note: To avoid ambiguity, we intentionally avoid the SPDX-compatible
+  # 'Ruby' for the Ruby 1.8 license.  This is because Ruby 1.9.3 switched
+  # to BSD-2-Clause, but we inherited our license from Mongrel when
+  # Ruby was at 1.8.  We cannot automatically switch licenses when Ruby
+  # changes; so we maintain the Ruby 1.8 license (not 1.9.3+) along
+  # with GPL-2.0+
+  s.licenses = %w(GPL-2.0+ Nonstandard)
 end

data/lib/kcar.rb

@@ -3,6 +3,6 @@ module Kcar
   autoload :Response, 'kcar/response'
 end
 
-require 'kcar/version'
-require 'kcar/parser'
+require_relative 'kcar/version'
+require_relative 'kcar/parser'
 require 'kcar_ext'

data/lib/kcar/response.rb

@@ -1,13 +1,11 @@
 # -*- encoding: binary -*-
 
 
-# This may be used to generate a Rack response
-#
-class Kcar::Response
-  attr_accessor :sock, :hdr, :unchunk, :buf, :parser
+# This may be used to generate a Rack response synchronously.
 
+class Kcar::Response
   # :stopdoc:
-  Parser = Kcar::Parser
+  attr_accessor :sock, :hdr, :unchunk, :buf, :parser
   # :startdoc:
 
   # By default we readpartial at most 16K off a socket at once
@@ -17,7 +15,8 @@ class Kcar::Response
   # method.  +unchunk+ may be set to disable transparent unchunking
   # +hdr+ may be a Hash, Array, or Rack::Utils::HeaderHash
   def initialize(sock, hdr = {}, unchunk = true)
-    @sock, @hdr, @unchunk, @buf, @parser = sock, hdr, unchunk, "", Parser.new
+    @sock, @hdr, @unchunk, @buf =  sock, hdr, unchunk, ""
+    @parser = Kcar::Parser.new
   end
 
   # returns a 3-element array that resembles a Rack response, but is
@@ -63,11 +62,11 @@ class Kcar::Response
   def each
     return if @parser.body_eof?
     if @unchunk
-      @parser.chunked? ? each_unchunk { |x| yield x } :
-                         each_identity { |x| yield x }
+      @parser.chunked? ? each_unchunk { |buf| yield buf } :
+                         each_identity { |buf| yield buf }
     else
-      @parser.chunked? ? each_rechunk { |x| yield x } :
-                         each_identity { |x| yield x }
+      @parser.chunked? ? each_rechunk { |buf| yield buf } :
+                         each_identity { |buf| yield buf }
     end
   end
 
@@ -142,7 +141,7 @@ class Kcar::Response
           len -= @sock.readpartial(len > READ_SIZE ? READ_SIZE : len, dst).size
           yield dst
         end while len > 0
-        dst.respond_to?(:clear) ? dst.clear : @buf = ""
+        dst.clear
       end
     end
     @parser.body_bytes_left = 0

data/pkg.mk

@@ -60,7 +60,7 @@ doc:: .document .olddoc.yml $(pkg_extra) $(PLACEHOLDERS)
 	-find lib -type f -name '*.rbc' -exec rm -f '{}' ';'
 	-find ext -type f -name '*.rbc' -exec rm -f '{}' ';'
 	$(RM) -r doc
-	$(RDOC) -f oldweb
+	$(RDOC) -f dark216
 	$(OLDDOC) merge
 	install -m644 COPYING doc/COPYING
 	install -m644 NEWS doc/NEWS
@@ -86,7 +86,7 @@ fix-perms:
 gem: $(pkggem)
 
 install-gem: $(pkggem)
-	gem install $(CURDIR)/$<
+	gem install --local $(CURDIR)/$<
 
 $(pkggem): manifest fix-perms
 	gem build $(rfpackage).gemspec
@@ -119,7 +119,7 @@ test: check
 check: test-unit
 test-unit: $(test_units)
 $(test_units): build
-	$(RUBY) -I $(lib) $@ $(RUBY_TEST_OPTS)
+	$(VALGRIND) $(RUBY) -w -I $(lib) $@ $(RUBY_TEST_OPTS)
 
 # this requires GNU coreutils variants
 ifneq ($(RSYNC_DEST),)

data/test/test_parser.rb

@@ -254,6 +254,12 @@ class TestParser < Test::Unit::TestCase
     end
   end
 
+  def test_bad_cr
+    assert_raises(Kcar::ParserError) do
+      @hp.headers([], "HTTP/1.1 200 OK\r\nContent-Length: 5\r\nA:\rb")
+    end
+  end
+
   def test_leading_tab
     resp = "HTTP/1.1 200 OK\r\nHost:\texample.com\r\n\r\n"
     assert @hp.headers(env = {}, resp)
@@ -289,4 +295,30 @@ class TestParser < Test::Unit::TestCase
     assert @hp.headers(env = {}, resp)
     assert_equal '', env['Host']
   end
+
+  def test_memsize
+    require 'objspace'
+    n = ObjectSpace.memsize_of(@hp)
+    assert_kind_of Integer, n
+    warn "memsize: #{n}\n" if $DEBUG
+  rescue LoadError
+    warn 'ObjectSpace not available'
+  end
+
+  def test_uminus_dd
+    # oddly, opt_str_freeze is not always effective:
+    # https://bugs.ruby-lang.org/issues/13282
+    a = -(%w(H o s t).join)
+    b = -(%w(H o s t).join)
+    if a.object_id == b.object_id
+      resp = "HTTP/1.1 200 OK\r\nHost: example.com\r\n\r\n"
+      assert @hp.headers(e = {}, resp.dup)
+      @hp.reset
+      assert @hp.headers(f = {}, resp.dup)
+      assert_same e.keys[0], f.keys[0]
+      assert_same a, e.keys[0]
+    else
+      warn "String#-@ does not dedupe with #{RUBY_ENGINE}-#{RUBY_VERSION}"
+    end
+  end
 end

data/test/test_request_parser.rb

@@ -0,0 +1,1219 @@
+# -*- encoding: binary -*-
+## Copyright (c) 2005 Zed A. Shaw
+# You can redistribute it and/or modify it under the same terms as Ruby 1.8
+# or GPL-2.0+ <https://www.gnu.org/licenses/gpl-2.0.txt>
+#
+# Additional work donated by contributors.  See git history of
+# unicorn for more information: git clone https://yhbt.net/unicorn.git
+
+require 'test/unit'
+require 'digest'
+require 'kcar'
+require 'uri'
+
+class TestRequestParser < Test::Unit::TestCase
+  def setup
+    @hp = Kcar::Parser.new
+    @env = {}
+  end
+
+  def test_parse_oneshot_simple
+    buf = "GET / HTTP/1.1\r\n\r\n"
+    http = 'http'.freeze
+    @env['rack.url_scheme'] = http
+    env = @hp.request(@env, buf.dup)
+    assert_same env, @env
+    exp = {
+      'SERVER_PROTOCOL' => 'HTTP/1.1',
+      'HTTP_VERSION' => 'HTTP/1.1',
+      'REQUEST_PATH' => '/',
+      'PATH_INFO' => '/',
+      'REQUEST_URI' => '/',
+      'REQUEST_METHOD' => 'GET',
+      'QUERY_STRING' => '',
+      'rack.url_scheme' => 'http',
+    }
+    assert_equal exp, env
+    assert_same env['HTTP_VERSION'], env['SERVER_PROTOCOL']
+    assert_predicate env['HTTP_VERSION'], :frozen?
+    assert_predicate env['REQUEST_METHOD'], :frozen?
+    assert_same http, env['rack.url_scheme']
+    assert_predicate @hp, :keepalive?
+
+    @hp.reset
+
+    buf = "G"
+    assert_nil @hp.request(@env, buf)
+    # try parsing again to ensure we were reset correctly
+    buf << "ET /hello-world HTTP/1.1\r\n\r\n"
+    assert_same env, @hp.request(env, buf)
+
+    assert_equal 'HTTP/1.1', env['SERVER_PROTOCOL']
+    assert_equal '/hello-world', env['REQUEST_PATH']
+    assert_equal 'HTTP/1.1', env['HTTP_VERSION']
+    assert_equal '/hello-world', env['REQUEST_URI']
+    assert_equal 'GET', env['REQUEST_METHOD']
+    assert_equal '', env['QUERY_STRING']
+    assert @hp.keepalive?
+  end
+
+  def test_tab_lws
+    @hp.request(@env, "GET / HTTP/1.1\r\nHost:\tfoo.bar\r\n\r\n")
+    assert_equal "foo.bar", @env['HTTP_HOST']
+  end
+
+  def test_connection_close_no_ka
+    @hp.request(@env = {}, "GET / HTTP/1.1\r\nConnection: close\r\n\r\n")
+    assert_equal 'GET', @env['REQUEST_METHOD']
+    assert ! @hp.keepalive?
+  end
+
+  def test_connection_keep_alive_ka
+    @hp.request(@env, "HEAD / HTTP/1.1\r\nConnection: keep-alive\r\n\r\n")
+    assert @hp.keepalive?
+  end
+
+  def test_connection_keep_alive_no_body
+    r = @hp.request(@env, "POST / HTTP/1.1\r\nConnection: keep-alive\r\n\r\n")
+    assert_same @env, r
+    assert @hp.keepalive?
+  end
+
+  def test_connection_keep_alive_no_body_empty
+    buf = "POST / HTTP/1.1\r\n" \
+          "Content-Length: 0\r\n" \
+          "Connection: keep-alive\r\n\r\n"
+    assert_same @env, @hp.request(@env, buf)
+    assert @hp.keepalive?
+  end
+
+  def test_connection_keep_alive_ka_bad_version
+    @hp.request(@env, "GET / HTTP/1.0\r\nConnection: keep-alive\r\n\r\n")
+    assert @hp.keepalive?
+  end
+
+  def test_parse_server_host_default_port
+    buf = "GET / HTTP/1.1\r\nHost: foo\r\n\r\n"
+    assert_same @env, @hp.request(@env, buf)
+    assert_equal 'foo', @env['SERVER_NAME']
+    assert_nil @env['SERVER_PORT']
+    assert_equal '', buf
+    assert @hp.keepalive?
+  end
+
+  def test_parse_server_host_alt_port
+    buf = "GET / HTTP/1.1\r\nHost: foo:999\r\n\r\n"
+    @hp.request(@env, buf)
+    assert_equal 'foo', @env['SERVER_NAME']
+    assert_equal '999', @env['SERVER_PORT']
+    assert_equal '', buf
+    assert @hp.keepalive?
+  end
+
+  def test_parse_server_host_empty_port
+    @hp.request(@env, "GET / HTTP/1.1\r\nHost: foo:\r\n\r\n")
+    assert_equal 'foo', @env['SERVER_NAME']
+    assert_nil @env['SERVER_PORT']
+    assert @hp.keepalive?
+  end
+
+  def test_parse_host_cont
+    @hp.request(@env, "GET / HTTP/1.1\r\nHost:\r\n foo\r\n\r\n")
+    assert_equal 'foo', @env['SERVER_NAME']
+    assert_nil @env['SERVER_PORT']
+    assert @hp.keepalive?
+  end
+
+  def test_preserve_existing_server_vars
+    @env = {
+      'SERVER_NAME' => 'example.com',
+      'SERVER_PORT' => '1234',
+      'rack.url_scheme' => 'https'
+    }
+    @hp.request(@env, "GET / HTTP/1.0\r\n\r\n")
+    assert_equal 'example.com', @env['SERVER_NAME']
+    assert_equal '1234', @env['SERVER_PORT']
+    assert_equal 'https', @env['rack.url_scheme']
+  end
+
+  def test_parse_strange_headers
+    should_be_good = "GET / HTTP/1.1\r\naaaaaaaaaaaaa:++++++++++\r\n\r\n"
+    req = @hp.request(@env, should_be_good)
+    assert_same req, @env
+    assert_equal '', should_be_good
+    assert_predicate @hp, :keepalive?
+    assert_equal '++++++++++', @env['HTTP_AAAAAAAAAAAAA']
+  end
+
+  # legacy test case from Mongrel
+  # I still consider Pound irrelevant, unfortunately stupid clients that
+  # send extremely big headers do exist and they've managed to find us...
+  def test_nasty_pound_header
+    nasty_pound_header = "GET / HTTP/1.1\r\n" \
+"X-SSL-Bullshit:   -----BEGIN CERTIFICATE-----\r\n" \
+"\tMIIFbTCCBFWgAwIBAgICH4cwDQYJKoZIhvcNAQEFBQAwcDELMAkGA1UEBhMCVUsx\r\n" \
+"\tETAPBgNVBAoTCGVTY2llbmNlMRIwEAYDVQQLEwlBdXRob3JpdHkxCzAJBgNVBAMT\r\n" \
+"\tAkNBMS0wKwYJKoZIhvcNAQkBFh5jYS1vcGVyYXRvckBncmlkLXN1cHBvcnQuYWMu\r\n" \
+"\tdWswHhcNMDYwNzI3MTQxMzI4WhcNMDcwNzI3MTQxMzI4WjBbMQswCQYDVQQGEwJV\r\n" \
+"\tSzERMA8GA1UEChMIZVNjaWVuY2UxEzARBgNVBAsTCk1hbmNoZXN0ZXIxCzAJBgNV\r\n" \
+"\tBAcTmrsogriqMWLAk1DMRcwFQYDVQQDEw5taWNoYWVsIHBhcmQYJKoZIhvcNAQEB\r\n" \
+"\tBQADggEPADCCAQoCggEBANPEQBgl1IaKdSS1TbhF3hEXSl72G9J+WC/1R64fAcEF\r\n" \
+"\tW51rEyFYiIeZGx/BVzwXbeBoNUK41OK65sxGuflMo5gLflbwJtHBRIEKAfVVp3YR\r\n" \
+"\tgW7cMA/s/XKgL1GEC7rQw8lIZT8RApukCGqOVHSi/F1SiFlPDxuDfmdiNzL31+sL\r\n" \
+"\t0iwHDdNkGjy5pyBSB8Y79dsSJtCW/iaLB0/n8Sj7HgvvZJ7x0fr+RQjYOUUfrePP\r\n" \
+"\tu2MSpFyf+9BbC/aXgaZuiCvSR+8Snv3xApQY+fULK/xY8h8Ua51iXoQ5jrgu2SqR\r\n" \
+"\twgA7BUi3G8LFzMBl8FRCDYGUDy7M6QaHXx1ZWIPWNKsCAwEAAaOCAiQwggIgMAwG\r\n" \
+"\tA1UdEwEB/wQCMAAwEQYJYIZIAYb4QgEBBAQDAgWgMA4GA1UdDwEB/wQEAwID6DAs\r\n" \
+"\tBglghkgBhvhCAQ0EHxYdVUsgZS1TY2llbmNlIFVzZXIgQ2VydGlmaWNhdGUwHQYD\r\n" \
+"\tVR0OBBYEFDTt/sf9PeMaZDHkUIldrDYMNTBZMIGaBgNVHSMEgZIwgY+AFAI4qxGj\r\n" \
+"\tloCLDdMVKwiljjDastqooXSkcjBwMQswCQYDVQQGEwJVSzERMA8GA1UEChMIZVNj\r\n" \
+"\taWVuY2UxEjAQBgNVBAsTCUF1dGhvcml0eTELMAkGA1UEAxMCQ0ExLTArBgkqhkiG\r\n" \
+"\t9w0BCQEWHmNhLW9wZXJhdG9yQGdyaWQtc3VwcG9ydC5hYy51a4IBADApBgNVHRIE\r\n" \
+"\tIjAggR5jYS1vcGVyYXRvckBncmlkLXN1cHBvcnQuYWMudWswGQYDVR0gBBIwEDAO\r\n" \
+"\tBgwrBgEEAdkvAQEBAQYwPQYJYIZIAYb4QgEEBDAWLmh0dHA6Ly9jYS5ncmlkLXN1\r\n" \
+"\tcHBvcnQuYWMudmT4sopwqlBWsvcHViL2NybC9jYWNybC5jcmwwPQYJYIZIAYb4QgEDBDAWLmh0\r\n" \
+"\tdHA6Ly9jYS5ncmlkLXN1cHBvcnQuYWMudWsvcHViL2NybC9jYWNybC5jcmwwPwYD\r\n" \
+"\tVR0fBDgwNjA0oDKgMIYuaHR0cDovL2NhLmdyaWQt5hYy51ay9wdWIv\r\n" \
+"\tY3JsL2NhY3JsLmNybDANBgkqhkiG9w0BAQUFAAOCAQEAS/U4iiooBENGW/Hwmmd3\r\n" \
+"\tXCy6Zrt08YjKCzGNjorT98g8uGsqYjSxv/hmi0qlnlHs+k/3Iobc3LjS5AMYr5L8\r\n" \
+"\tUO7OSkgFFlLHQyC9JzPfmLCAugvzEbyv4Olnsr8hbxF1MbKZoQxUZtMVu29wjfXk\r\n" \
+"\thTeApBv7eaKCWpSp7MCbvgzm74izKhu3vlDk9w6qVrxePfGgpKPqfHiOoGhFnbTK\r\n" \
+"\twTC6o2xq5y0qZ03JonF7OJspEd3I5zKY3E+ov7/ZhW6DqT8UFvsAdjvQbXyhV8Eu\r\n" \
+"\tYhixw1aKEPzNjNowuIseVogKOLXxWI5vAi5HgXdS0/ES5gDGsABo4fqovUKlgop3\r\n" \
+"\tRA==\r\n" \
+"\t-----END CERTIFICATE-----\r\n" \
+"\r\n"
+    ok = (/(-----BEGIN .*--END CERTIFICATE-----)/m =~ nasty_pound_header)
+    expect = $1.dup
+    assert ok, 'end certificate matched'
+    expect.gsub!(/\r\n\t/, ' ')
+    req = @hp.request(@env, nasty_pound_header.dup)
+    assert_equal expect, req['HTTP_X_SSL_BULLSHIT']
+  end
+
+  def test_multiline_header_0d0a
+    req = @hp.request(@env, "GET / HTTP/1.0\r\n" \
+      "X-Multiline-Header: foo bar\r\n\tcha cha\r\n\tzha zha\r\n\r\n")
+    assert_same req, @env
+    assert_equal 'foo bar cha cha zha zha', req['HTTP_X_MULTILINE_HEADER']
+  end
+
+  def test_multiline_header_0a
+    req = @hp.request(@env, "GET / HTTP/1.0\n" \
+      "X-Multiline-Header: foo bar\n\tcha cha\n\tzha zha\n\n")
+    assert_same req, @env
+    assert_equal 'foo bar cha cha zha zha', req['HTTP_X_MULTILINE_HEADER']
+  end
+
+  def test_continuation_eats_leading_spaces
+    header = "GET / HTTP/1.1\r\n" \
+             "X-ASDF:      \r\n" \
+             "\t\r\n" \
+             "    \r\n" \
+             "  ASDF\r\n\r\n"
+    req = @hp.request(@env, header)
+    assert_same req, @env
+    assert_equal '', header
+    assert_equal 'ASDF', req['HTTP_X_ASDF']
+  end
+
+  def test_continuation_eats_scattered_leading_spaces
+    header = "GET / HTTP/1.1\r\n" \
+             "X-ASDF:   hi\r\n" \
+             "    y\r\n" \
+             "\t\r\n" \
+             "       x\r\n" \
+             "  ASDF\r\n\r\n"
+    req = @hp.request(@env, header)
+    assert_same req, @env
+    assert_equal '', header
+    assert_equal 'hi y x ASDF', req['HTTP_X_ASDF']
+  end
+
+  def test_continuation_eats_trailing_spaces
+    header = "GET / HTTP/1.1\r\n" \
+             "X-ASDF:      \r\n" \
+             "\t\r\n" \
+             "  b  \r\n" \
+             "  ASDF\r\n\r\nZ"
+    req = @hp.request(@env, header)
+    assert_same req, @env
+    assert_equal 'Z', header
+    assert_equal 'b ASDF', req['HTTP_X_ASDF']
+  end
+
+  def test_continuation_with_absolute_uri_and_ignored_host_header
+    header = "GET http://example.com/ HTTP/1.1\r\n" \
+             "Host: \r\n" \
+             "    example.org\r\n" \
+             "\r\n"
+    req = @hp.request(@env, header)
+    assert_same req, @env
+    assert_equal 'example.com', req['HTTP_HOST']
+    assert_equal 'http', req['rack.url_scheme']
+    assert_equal '/', req['PATH_INFO']
+    assert_equal 'example.com', req['SERVER_NAME']
+    assert_equal '80', req['SERVER_PORT']
+  end
+
+  # this may seem to be testing more of an implementation detail, but
+  # it also helps ensure we're safe in the presence of multiple parsers
+  # in case we ever go multithreaded/evented...
+  def test_resumable_continuations
+    nr = 1000
+    header = "GET / HTTP/1.1\r\n" \
+             "X-ASDF:      \r\n" \
+             "  hello\r\n"
+    tmp = []
+    nr.times { |i|
+      hp = Kcar::Parser.new
+      env = {}
+      assert_nil hp.request(env, buf = "#{header} #{i}\r\n")
+      asdf = env['HTTP_X_ASDF']
+      assert_equal "hello #{i}", asdf
+      tmp << [ hp, asdf, env, buf ]
+    }
+    tmp.each_with_index { |(hp, asdf, env, buf), i|
+      buf << " .\r\n\r\n"
+      assert_same env, hp.request(env, buf)
+      assert_equal "hello #{i} .", asdf
+    }
+  end
+
+  def test_invalid_continuation
+    header = "GET / HTTP/1.1\r\n" \
+             "    y\r\n" \
+             "Host: hello\r\n" \
+             "\r\n"
+    buf = header.dup
+    assert_raises(Kcar::ParserError) do
+      @hp.request(@env, buf)
+    end
+    assert_equal header, buf, 'no modification on invalid'
+  end
+
+  def test_parse_ie6_urls
+    %w(/some/random/path"
+       /some/random/path>
+       /some/random/path<
+       /we/love/you/ie6?q=<"">
+       /url?<="&>="
+       /mal"formed"?
+    ).each do |path|
+      sorta_safe = %(GET #{path} HTTP/1.1\r\n\r\n)
+      assert_same @env, @hp.request(@env, sorta_safe)
+      assert_equal path, @env['REQUEST_URI']
+      assert_equal '', sorta_safe
+      assert @hp.keepalive?
+      @hp.reset
+    end
+  end
+
+  def test_parse_error
+    bad_http = "GET / SsUTF/1.1"
+    assert_raises(Kcar::ParserError) { @hp.request(@env, bad_http) }
+
+    # make sure we can recover
+    @env.clear
+    @hp.reset
+    assert_equal @env, @hp.request(@env, "GET / HTTP/1.0\r\n\r\n")
+    assert ! @hp.keepalive?
+  end
+
+  def test_piecemeal
+    http = "GET"
+    req = @env
+    assert_nil @hp.request(@env, http)
+    assert_nil @hp.request(@env, http)
+    assert_nil @hp.request(@env, http << " / HTTP/1.0")
+    assert_equal '/', req['REQUEST_PATH']
+    assert_equal '/', req['REQUEST_URI']
+    assert_equal 'GET', req['REQUEST_METHOD']
+    assert_nil @hp.request(req, http << "\r\n")
+    assert_equal 'HTTP/1.0', req['HTTP_VERSION']
+    assert_nil @hp.request(req, http << "\r")
+    assert_same req, @hp.request(req, http << "\n")
+    assert_equal 'HTTP/1.0', req['SERVER_PROTOCOL']
+    assert_nil req['FRAGMENT']
+    assert_equal '', req['QUERY_STRING']
+    assert_equal "", http
+    assert ! @hp.keepalive?
+  end
+
+  # not common, but underscores do appear in practice
+  def test_absolute_uri_underscores
+    http = "GET https://under_score.example.com/foo?q=bar HTTP/1.0\r\n\r\n"
+    req = @hp.request(@env, http)
+    assert_same req, @env
+    assert_equal 'https', req['rack.url_scheme']
+    assert_equal '/foo?q=bar', req['REQUEST_URI']
+    assert_equal '/foo', req['REQUEST_PATH']
+    assert_equal 'q=bar', req['QUERY_STRING']
+    assert_equal 'under_score.example.com', req['HTTP_HOST']
+    assert_equal 'under_score.example.com', req['SERVER_NAME']
+    assert_equal '443', req['SERVER_PORT']
+    assert_equal "", http
+    assert ! @hp.keepalive?
+  end
+
+  # some dumb clients add users because they're stupid
+  def test_absolute_uri_w_user
+    http = "GET http://user%20space@example.com/foo?q=bar HTTP/1.0\r\n\r\n"
+    req = @hp.request(@env, http)
+    assert_same req, @env
+    assert_equal 'http', req['rack.url_scheme']
+    assert_equal '/foo?q=bar', req['REQUEST_URI']
+    assert_equal '/foo', req['REQUEST_PATH']
+    assert_equal 'q=bar', req['QUERY_STRING']
+    assert_equal 'example.com', req['HTTP_HOST']
+    assert_equal 'example.com', req['SERVER_NAME']
+    assert_equal '80', req['SERVER_PORT']
+    assert_equal "", http
+    assert ! @hp.keepalive?
+  end
+
+  # since Mongrel supported anything URI.parse supported, we're stuck
+  # supporting everything URI.parse supports
+  def test_absolute_uri_uri_parse
+    require 'uri'
+    "#{URI::REGEXP::PATTERN::UNRESERVED};:&=+$,".split(//).each do |char|
+      http = "GET http://#{char}@example.com/ HTTP/1.0\r\n\r\n"
+      req = @hp.request(@env, http)
+      assert_equal 'http', req['rack.url_scheme']
+      assert_equal '/', req['REQUEST_URI']
+      assert_equal '/', req['REQUEST_PATH']
+      assert_equal '', req['QUERY_STRING']
+
+      assert_equal 'example.com', req['HTTP_HOST']
+      assert_equal 'example.com', req['SERVER_NAME']
+      assert_equal '80', req['SERVER_PORT']
+      assert_equal "", http
+      assert ! @hp.keepalive?
+      @hp.reset
+    end
+  end
+
+  def test_absolute_uri
+    req = @hp.request(@env, "GET http://example.com/foo?q=bar HTTP/1.0\r\n\r\n")
+    assert_equal 'http', req['rack.url_scheme']
+    assert_equal '/foo?q=bar', req['REQUEST_URI']
+    assert_equal '/foo', req['REQUEST_PATH']
+    assert_equal 'q=bar', req['QUERY_STRING']
+    assert_equal '80', req['SERVER_PORT']
+    assert_equal 'example.com', req['HTTP_HOST']
+    assert_equal 'example.com', req['SERVER_NAME']
+    assert ! @hp.keepalive?
+  end
+
+  def test_absolute_uri_https
+    http = "GET https://example.com/foo?q=bar HTTP/1.1\r\n" \
+           "X-Foo: bar\n\r\n"
+    req = @hp.request(@env, http)
+    assert_equal 'https', req['rack.url_scheme']
+    assert_equal '/foo?q=bar', req['REQUEST_URI']
+    assert_equal '/foo', req['REQUEST_PATH']
+    assert_equal 'q=bar', req['QUERY_STRING']
+    assert_equal 'example.com', req['HTTP_HOST']
+    assert_equal 'example.com', req['SERVER_NAME']
+    assert_equal '443', req['SERVER_PORT']
+    assert_equal "", http
+    assert @hp.keepalive?
+  end
+
+  # Host: header should be ignored for absolute URIs
+  def test_absolute_uri_with_port
+    req = @hp.request(@env,"GET http://example.com:8080/foo?q=bar HTTP/1.1\r\n" \
+           "Host: bad.example.com\r\n\r\n")
+    assert_equal 'http', req['rack.url_scheme']
+    assert_equal '/foo?q=bar', req['REQUEST_URI']
+    assert_equal '/foo', req['REQUEST_PATH']
+    assert_equal 'q=bar', req['QUERY_STRING']
+    assert_equal 'example.com:8080', req['HTTP_HOST']
+    assert_equal 'example.com', req['SERVER_NAME']
+    assert_equal '8080', req['SERVER_PORT']
+    assert @hp.keepalive?
+  end
+
+  def test_absolute_uri_with_empty_port
+    req = @hp.request(@env, "GET https://example.com:/foo?q=bar HTTP/1.1\r\n" \
+           "Host: bad.example.com\r\n\r\n")
+    assert_same req, @env
+    assert_equal 'https', req['rack.url_scheme']
+    assert_equal '/foo?q=bar', req['REQUEST_URI']
+    assert_equal '/foo', req['REQUEST_PATH']
+    assert_equal 'q=bar', req['QUERY_STRING']
+    assert_equal 'example.com:', req['HTTP_HOST']
+    assert_equal 'example.com', req['SERVER_NAME']
+    assert_equal '443', req['SERVER_PORT']
+    assert @hp.keepalive?
+  end
+
+  def test_absolute_ipv6_uri
+    url = "http://[::1]/foo?q=bar"
+    http = "GET #{url} HTTP/1.1\r\n" \
+           "Host: bad.example.com\r\n\r\n"
+    req = @hp.request(@env, http)
+    assert_same req, @env
+    assert_equal 'http', req['rack.url_scheme']
+    assert_equal '/foo?q=bar', req['REQUEST_URI']
+    assert_equal '/foo', req['REQUEST_PATH']
+    assert_equal 'q=bar', req['QUERY_STRING']
+
+    uri = URI.parse(url)
+    assert_equal "[::1]", uri.host,
+                 "URI.parse changed upstream for #{url}? host=#{uri.host}"
+    assert_equal "[::1]", req['HTTP_HOST']
+    assert_equal "[::1]", req['SERVER_NAME']
+    assert_equal '80', req['SERVER_PORT']
+    assert_equal "", http
+  end
+
+  def test_absolute_ipv6_uri_alpha
+    url = "http://[::a]/"
+    http = "GET #{url} HTTP/1.1\r\n" \
+           "Host: bad.example.com\r\n\r\n"
+    req = @hp.request(@env, http)
+    assert_equal 'http', req['rack.url_scheme']
+    uri = URI.parse(url)
+    assert_equal "[::a]", uri.host,
+                 "URI.parse changed upstream for #{url}? host=#{uri.host}"
+    assert_equal "[::a]", req['HTTP_HOST']
+    assert_equal "[::a]", req['SERVER_NAME']
+    assert_equal '80', req['SERVER_PORT']
+  end
+
+  def test_absolute_ipv6_uri_alpha_2
+    url = "http://[::B]/"
+    http = "GET #{url} HTTP/1.1\r\n" \
+           "Host: bad.example.com\r\n\r\n"
+    req = @hp.request(@env, http)
+    assert_equal 'http', req['rack.url_scheme']
+
+    uri = URI.parse(url)
+    assert_equal "[::B]", uri.host,
+                 "URI.parse changed upstream for #{url}? host=#{uri.host}"
+    assert_equal "[::B]", req['HTTP_HOST']
+    assert_equal "[::B]", req['SERVER_NAME']
+    assert_equal '80', req['SERVER_PORT']
+  end
+
+  def test_absolute_ipv6_uri_with_empty_port
+    url = "https://[::1]:/foo?q=bar"
+    http = "GET #{url} HTTP/1.1\r\n" \
+           "Host: bad.example.com\r\n\r\n"
+    req = @hp.request(@env, http)
+    assert_equal 'https', req['rack.url_scheme']
+    assert_equal '/foo?q=bar', req['REQUEST_URI']
+    assert_equal '/foo', req['REQUEST_PATH']
+    assert_equal 'q=bar', req['QUERY_STRING']
+
+    uri = URI.parse(url)
+    assert_equal "[::1]", uri.host,
+                 "URI.parse changed upstream for #{url}? host=#{uri.host}"
+    assert_equal "[::1]:", req['HTTP_HOST']
+    assert_equal "[::1]", req['SERVER_NAME']
+    assert_equal '443', req['SERVER_PORT']
+    assert_equal "", http
+  end
+
+  def test_absolute_ipv6_uri_with_port
+    url = "https://[::1]:666/foo?q=bar"
+    http = "GET #{url} HTTP/1.1\r\n" \
+           "Host: bad.example.com\r\n\r\n"
+    req = @hp.request(@env, http)
+    assert_equal 'https', req['rack.url_scheme']
+    assert_equal '/foo?q=bar', req['REQUEST_URI']
+    assert_equal '/foo', req['REQUEST_PATH']
+    assert_equal 'q=bar', req['QUERY_STRING']
+
+    uri = URI.parse(url)
+    assert_equal "[::1]", uri.host,
+                 "URI.parse changed upstream for #{url}? host=#{uri.host}"
+    assert_equal "[::1]:666", req['HTTP_HOST']
+    assert_equal "[::1]", req['SERVER_NAME']
+    assert_equal '666', req['SERVER_PORT']
+    assert_equal "", http
+  end
+
+  def test_ipv6_host_header
+    buf = "GET / HTTP/1.1\r\n" \
+          "Host: [::1]\r\n\r\n"
+    req = @hp.request(@env, buf)
+    assert_equal "[::1]", req['HTTP_HOST']
+    assert_equal "[::1]", req['SERVER_NAME']
+    assert_nil req['SERVER_PORT']
+  end
+
+  def test_ipv6_host_header_with_port
+    req = @hp.request(@env, "GET / HTTP/1.1\r\n" \
+                  "Host: [::1]:666\r\n\r\n")
+    assert_equal "[::1]", req['SERVER_NAME']
+    assert_equal '666', req['SERVER_PORT']
+    assert_equal "[::1]:666", req['HTTP_HOST']
+  end
+
+  def test_ipv6_host_header_with_empty_port
+    req = @hp.request(@env, "GET / HTTP/1.1\r\nHost: [::1]:\r\n\r\n")
+    assert_equal "[::1]", req['SERVER_NAME']
+    assert_nil req['SERVER_PORT']
+    assert_equal "[::1]:", req['HTTP_HOST']
+  end
+
+  # XXX Highly unlikely..., just make sure we don't segfault or assert on it
+  def test_broken_ipv6_host_header
+    req = @hp.request(@env, "GET / HTTP/1.1\r\nHost: [::1:\r\n\r\n")
+    assert_equal "[", req['SERVER_NAME']
+    assert_equal ':1:', req['SERVER_PORT']
+    assert_equal "[::1:", req['HTTP_HOST']
+  end
+
+  def test_put_body_oneshot
+    buf = "PUT / HTTP/1.0\r\nContent-Length: 5\r\n\r\nabcde"
+    req = @hp.request(@env, buf)
+    assert_equal '/', req['REQUEST_PATH']
+    assert_equal '/', req['REQUEST_URI']
+    assert_equal 'PUT', req['REQUEST_METHOD']
+    assert_equal 'HTTP/1.0', req['HTTP_VERSION']
+    assert_equal 'HTTP/1.0', req['SERVER_PROTOCOL']
+    assert_equal "abcde", buf
+  end
+
+  def test_put_body_later
+    buf = "PUT /l HTTP/1.0\r\nContent-Length: 5\r\n\r\n"
+    req = @hp.request(@env, buf)
+    assert_equal '/l', req['REQUEST_PATH']
+    assert_equal '/l', req['REQUEST_URI']
+    assert_equal 'PUT', req['REQUEST_METHOD']
+    assert_equal 'HTTP/1.0', req['HTTP_VERSION']
+    assert_equal 'HTTP/1.0', req['SERVER_PROTOCOL']
+    assert_equal "", buf
+  end
+
+  def test_unknown_methods
+    %w(GETT HEADR XGET XHEAD).each { |m|
+      s = "#{m} /forums/1/topics/2375?page=1#posts-17408 HTTP/1.1\r\n\r\n"
+      req = @hp.request(@env, s)
+      assert_equal '/forums/1/topics/2375?page=1', req['REQUEST_URI']
+      assert_equal 'posts-17408', req['FRAGMENT']
+      assert_equal 'page=1', req['QUERY_STRING']
+      assert_equal "", s
+      assert_equal m, req['REQUEST_METHOD']
+      @hp.reset
+    }
+  end
+
+  def test_fragment_in_uri
+    get = "GET /forums/1/topics/2375?page=1#posts-17408 HTTP/1.1\r\n\r\n"
+    req = @hp.request(@env, get)
+    assert_equal '/forums/1/topics/2375?page=1', req['REQUEST_URI']
+    assert_equal 'posts-17408', req['FRAGMENT']
+    assert_equal 'page=1', req['QUERY_STRING']
+    assert_equal '', get
+  end
+
+  # lame random garbage maker
+  def rand_data(min, max, readable=true)
+    count = min + ((rand(max)+1) *10).to_i
+    res = count.to_s + "/"
+
+    if readable
+      res << Digest::SHA1.hexdigest(rand(count * 100).to_s) * (count / 40)
+    else
+      res << Digest::SHA1.digest(rand(count * 100).to_s) * (count / 20)
+    end
+
+    return res
+  end
+
+  def test_horrible_queries
+    # then that large header names are caught
+    10.times do |c|
+      get = "GET /#{rand_data(10,120)} HTTP/1.1\r\nX-#{rand_data(1024, 1024+(c*1024))}: Test\r\n\r\n"
+      assert_raises(Kcar::ParserError, Kcar::RequestURITooLongError) do
+        @hp.request(@env, get)
+        @hp.clear
+      end
+    end
+
+    # then that large mangled field values are caught
+    10.times do |c|
+      get = "GET /#{rand_data(10,120)} HTTP/1.1\r\nX-Test: #{rand_data(1024, 1024+(c*1024), false)}\r\n\r\n"
+      assert_raises(Kcar::ParserError,Kcar::RequestURITooLongError) do
+        @hp.request(@env, get)
+        @hp.clear
+      end
+    end
+
+    # then large headers are rejected too FIXME not supported, yet
+    if false
+      get = "GET /#{rand_data(10,120)} HTTP/1.1\r\n"
+      get << "X-Test: test\r\n" * (80 * 1024)
+      @hp.reset
+      assert_raises(Kcar::ParserError,Kcar::RequestURITooLongError) do
+        @hp.request(@env, get)
+      end
+    end
+
+    # finally just that random garbage gets blocked all the time
+    10.times do |c|
+      get = "GET #{rand_data(1024, 1024+(c*1024), false)} #{rand_data(1024, 1024+(c*1024), false)}\r\n\r\n"
+      @hp.reset
+      assert_raises(Kcar::ParserError,Kcar::RequestURITooLongError) do
+        @hp.request(@env, get)
+      end
+    end
+  end
+
+  def test_leading_tab
+    get = "GET / HTTP/1.1\r\nHost:\texample.com\r\n\r\n"
+    req = @hp.request(@env, get)
+    assert_equal 'example.com', req['HTTP_HOST']
+  end
+
+  def test_trailing_whitespace
+    get = "GET / HTTP/1.1\r\nHost: example.com \r\n\r\n"
+    req = @hp.request(@env, get)
+    assert_equal 'example.com', req['HTTP_HOST']
+  end
+
+  def test_trailing_tab
+    get = "GET / HTTP/1.1\r\nHost: example.com\t\r\n\r\n"
+    req = @hp.request(@env, get)
+    assert_equal 'example.com', req['HTTP_HOST']
+  end
+
+  def test_trailing_multiple_linear_whitespace
+    get = "GET / HTTP/1.1\r\nHost: example.com\t \t \t\r\n\r\n"
+    req = @hp.request(@env, get)
+    assert_equal 'example.com', req['HTTP_HOST']
+  end
+
+  def test_embedded_linear_whitespace_ok
+    get = "GET / HTTP/1.1\r\nX-Space: hello\t world\t \r\n\r\n"
+    req = @hp.request(@env, get)
+    assert_equal "hello\t world", req["HTTP_X_SPACE"]
+  end
+
+  def test_null_byte_header
+    get = "GET / HTTP/1.1\r\nHost: \0\r\n\r\n"
+    assert_raises(Kcar::ParserError) { @hp.request(@env, get) }
+  end
+
+  def test_null_byte_in_middle
+    get = "GET / HTTP/1.1\r\nHost: hello\0world\r\n\r\n"
+    assert_raises(Kcar::ParserError) { @hp.request(@env, get) }
+  end
+
+  def test_null_byte_at_end
+    get = "GET / HTTP/1.1\r\nHost: hello\0\r\n\r\n"
+    assert_raises(Kcar::ParserError) { @hp.request(@env, get) }
+  end
+
+  def test_empty_header
+    get = "GET / HTTP/1.1\r\nHost:  \r\n\r\n"
+    req = @hp.request(@env, get)
+    assert_equal '', req['HTTP_HOST']
+  end
+
+  def test_connection_TE
+    req = @hp.request(@env, "GET / HTTP/1.1\r\nHost: example.com\r\n" \
+                            "Connection: TE\r\n" \
+                            "TE: trailers\r\n\r\n")
+    assert_predicate @hp, :keepalive?
+    assert_equal 'TE', req['HTTP_CONNECTION']
+  end
+
+  def test_repeat_headers
+    str = "PUT / HTTP/1.1\r\n" \
+          "Trailer: Content-MD5\r\n" \
+          "Trailer: Content-SHA1\r\n" \
+          "transfer-Encoding: chunked\r\n\r\n" \
+          "1\r\na\r\n2\r\n..\r\n0\r\n"
+    req = @hp.request(@env, str)
+    assert_equal 'Content-MD5,Content-SHA1', req['HTTP_TRAILER']
+    assert_equal "1\r\na\r\n2\r\n..\r\n0\r\n", str
+    assert_not_predicate @hp, :keepalive?
+  end
+
+  def test_http_09
+    buf = "GET /read-rfc1945-if-you-dont-believe-me\r\n"
+    req = @hp.request(@env, buf)
+    assert_equal '', buf
+    expect = {
+      "REQUEST_PATH" => "/read-rfc1945-if-you-dont-believe-me",
+      "PATH_INFO" => "/read-rfc1945-if-you-dont-believe-me",
+      "REQUEST_URI" => "/read-rfc1945-if-you-dont-believe-me",
+      "REQUEST_METHOD" => "GET",
+      "QUERY_STRING" => ""
+    }
+    assert_equal expect, req
+  end
+
+  def test_path_info_semicolon
+    qs = "QUERY_STRING"
+    pi = "PATH_INFO"
+    req = {}
+    str = "GET %s HTTP/1.1\r\nHost: example.com\r\n\r\n"
+    {
+      "/1;a=b?c=d&e=f" => { qs => "c=d&e=f", pi => "/1;a=b" },
+      "/1?c=d&e=f" => { qs => "c=d&e=f", pi => "/1" },
+      "/1;a=b" => { qs => "", pi => "/1;a=b" },
+      "/1;a=b?" => { qs => "", pi => "/1;a=b" },
+      "/1?a=b;c=d&e=f" => { qs => "a=b;c=d&e=f", pi => "/1" },
+      "*" => { qs => "", pi => "" },
+    }.each do |uri,expect|
+      @env.clear
+      @hp.reset
+      buf = str % [ uri ]
+      req = @hp.request(@env, buf)
+      assert_equal uri, req["REQUEST_URI"], "REQUEST_URI mismatch"
+      assert_equal expect[qs], req[qs], "#{qs} mismatch"
+      assert_equal expect[pi], req[pi], "#{pi} mismatch"
+      next if uri == "*"
+      uri = URI.parse("http://example.com#{uri}")
+      assert_equal uri.query.to_s, req[qs], "#{qs} mismatch URI.parse disagrees"
+      assert_equal uri.path, req[pi], "#{pi} mismatch URI.parse disagrees"
+    end
+  end
+
+  def test_path_info_semicolon_absolute
+    qs = "QUERY_STRING"
+    pi = "PATH_INFO"
+    str = "GET http://example.com%s HTTP/1.1\r\nHost: www.example.com\r\n\r\n"
+    {
+      "/1;a=b?c=d&e=f" => { qs => "c=d&e=f", pi => "/1;a=b" },
+      "/1?c=d&e=f" => { qs => "c=d&e=f", pi => "/1" },
+      "/1;a=b" => { qs => "", pi => "/1;a=b" },
+      "/1;a=b?" => { qs => "", pi => "/1;a=b" },
+      "/1?a=b;c=d&e=f" => { qs => "a=b;c=d&e=f", pi => "/1" },
+    }.each do |uri,expect|
+      @hp.reset
+      @env.clear
+      buf = str % [ uri ]
+      req = @hp.request(@env, buf)
+      assert_equal uri, req["REQUEST_URI"], "REQUEST_URI mismatch"
+      assert_equal "example.com", req["HTTP_HOST"], "Host: mismatch"
+      assert_equal expect[qs], req[qs], "#{qs} mismatch"
+      assert_equal expect[pi], req[pi], "#{pi} mismatch"
+    end
+  end
+
+  def test_negative_content_length
+    str = "PUT / HTTP/1.1\r\n" \
+          "Content-Length: -1\r\n" \
+          "\r\n"
+    assert_raises(Kcar::ParserError) do
+      @hp.request(@env, str)
+    end
+  end
+
+  def test_invalid_content_length
+    str = "PUT / HTTP/1.1\r\n" \
+          "Content-Length: zzzzz\r\n" \
+          "\r\n"
+    assert_raises(Kcar::ParserError) do
+      @hp.request(@env, str)
+    end
+  end
+
+  def test_ignore_version_header
+    req = @hp.request(@env, "GET / HTTP/1.1\r\nVersion: hello\r\n\r\n")
+    expect = {
+      'REQUEST_PATH' => '/',
+      'SERVER_PROTOCOL' => 'HTTP/1.1',
+      'PATH_INFO' => '/',
+      'HTTP_VERSION' => 'HTTP/1.1',
+      'REQUEST_URI' => '/',
+      'REQUEST_METHOD' => 'GET',
+      'QUERY_STRING' => ''
+    }
+    assert_equal expect, req
+  end
+
+  def test_pipelined_requests
+    expect = {
+      'HTTP_HOST' => 'example.com',
+      'SERVER_NAME' => 'example.com',
+      'REQUEST_PATH' => '/',
+      'SERVER_PROTOCOL' => 'HTTP/1.1',
+      'PATH_INFO' => '/',
+      'HTTP_VERSION' => 'HTTP/1.1',
+      'REQUEST_URI' => '/',
+      'REQUEST_METHOD' => 'GET',
+      'QUERY_STRING' => ''
+    }
+    req1 = "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n"
+    req2 = "GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n"
+    buf = req1 + req2
+    env1 = @hp.request(@env, buf)
+    assert_equal expect, env1
+    assert_equal req2, buf
+    assert_predicate @hp, :keepalive?
+    @env.clear
+    @hp.reset
+    env2 = @hp.request(@env, buf)
+    expect['HTTP_HOST'] = expect['SERVER_NAME'] = 'www.example.com'
+    assert_equal expect, env2
+    assert_equal '', buf
+  end
+
+  def test_identity_byte_headers
+    str = "PUT / HTTP/1.1\r\n"
+    str << "Content-Length: 123\r\n"
+    str << "\r"
+    buf = ''
+    str.each_byte { |byte|
+      buf << byte.chr
+      assert_nil @hp.request(@env, str)
+    }
+    buf << "\n"
+    req = @hp.request(@env, buf)
+    assert_equal '123', req['CONTENT_LENGTH']
+    assert_predicate buf, :empty?
+    assert ! @hp.keepalive?
+    assert_equal 123, @hp.body_bytes_left
+    dst = ""
+    buf = '.' * 123
+    @hp.filter_body(dst, buf)
+    assert_equal '.' * 123, dst
+    assert_equal "", buf
+    assert_predicate @hp, :keepalive?
+  end
+
+  def test_identity_step_headers
+    str = "PUT / HTTP/1.1\r\n"
+    assert_nil @hp.request(@env, str)
+    str << "Content-Length: 123\r\n"
+    assert_nil @hp.request(@env, str)
+    str << "\r\n"
+    req = @hp.request(@env, str)
+    assert_equal '123', req['CONTENT_LENGTH']
+    assert_equal 0, str.size
+    assert_not_predicate @hp, :keepalive?
+    dst = ""
+    buf = '.' * 123
+    @hp.filter_body(dst, buf)
+    assert_equal '.' * 123, dst
+    assert_equal "", buf
+    assert_predicate @hp, :keepalive?
+  end
+
+  def test_identity_oneshot_header
+    str = "PUT / HTTP/1.1\r\nContent-Length: 123\r\n\r\n"
+    req = @hp.request(@env, str)
+    assert_equal '123', req['CONTENT_LENGTH']
+    assert_equal 0, str.size
+    assert_not_predicate @hp, :keepalive?
+    dst = ""
+    buf = '.' * 123
+    @hp.filter_body(dst, buf)
+    assert_equal '.' * 123, dst
+    assert_equal "", buf
+    assert_predicate @hp, :keepalive?
+  end
+
+  def test_identity_oneshot_header_with_body
+    body = ('a' * 123).freeze
+    str = "PUT / HTTP/1.1\r\n" \
+           "Content-Length: #{body.length}\r\n" \
+           "\r\n#{body}"
+    req = @hp.request(@env, str)
+    assert_equal '123', req['CONTENT_LENGTH']
+    assert_equal 123, str.size
+    assert_equal body, str
+    tmp = ''
+    assert_same tmp, @hp.filter_body(tmp, str)
+    assert_equal 0, str.size
+    assert_equal tmp, body
+    assert_equal body, @hp.filter_body(tmp, str)
+    assert_predicate @hp, :keepalive?
+  end
+
+  def test_identity_oneshot_header_with_body_partial
+    str = "PUT / HTTP/1.1\r\nContent-Length: 123\r\n\r\na"
+    req = @hp.request(@env, str)
+    assert_equal 1, str.size
+    assert_equal 'a', str
+    tmp = ''
+    assert_same tmp, @hp.filter_body(tmp, str)
+    assert_equal "", str
+    assert_equal "a", tmp
+    str << ' ' * 122
+    rv = @hp.filter_body(tmp, str)
+    assert_equal 122, tmp.size
+    assert_same tmp, rv
+    assert_equal "", str
+    assert_same tmp, @hp.filter_body(tmp, str)
+    assert_predicate @hp, :keepalive?
+    assert_equal '123', req['CONTENT_LENGTH']
+  end
+
+  def test_identity_oneshot_header_with_body_slop
+    str = "PUT / HTTP/1.1\r\nContent-Length: 1\r\n\r\naG"
+    req = @hp.request(@env, str)
+    assert_equal 2, str.size
+    assert_equal 'aG', str
+    tmp = ''
+    assert_same tmp, @hp.filter_body(tmp, str)
+    assert_equal "G", str
+    assert_equal "a", @hp.filter_body(tmp, str)
+    assert_equal 1, tmp.size
+    assert_equal "a", tmp
+    assert_predicate @hp, :keepalive?
+    assert_equal '1', req['CONTENT_LENGTH']
+  end
+
+  def test_chunked
+    str = "PUT / HTTP/1.1\r\ntransfer-Encoding: chunked\r\n\r\n"
+    req = @hp.request(@env, str)
+    assert_equal 0, str.size
+    tmp = ""
+    assert_predicate @hp, :chunked?
+    assert_nil @hp.filter_body(tmp, str << "6")
+    assert_equal 0, tmp.size
+    assert_nil @hp.filter_body(tmp, str << "\r\n")
+    assert_equal 0, str.size
+    assert_equal 0, tmp.size
+    tmp = ""
+    assert_nil @hp.filter_body(tmp, str << "..")
+    assert_equal "..", tmp
+    assert_nil @hp.filter_body(tmp, str << "abcd\r\n0\r\n")
+    assert_equal "abcd", tmp
+    assert_same tmp, @hp.filter_body(tmp, str << "PUT")
+    assert_equal "PUT", str
+    assert_not_predicate @hp, :keepalive?
+    str << "TY: FOO\r\n\r\n"
+    req = @hp.request(@env, str)
+    assert_equal "FOO", req["HTTP_PUTTY"]
+    assert_predicate @hp, :keepalive?
+  end
+
+  def test_chunked_empty
+    str = "PUT / HTTP/1.1\r\ntransfer-Encoding: chunked\r\n\r\n"
+    req = @hp.request(@env, str)
+    assert_equal 0, str.size
+    tmp = ""
+    assert_same tmp, @hp.filter_body(tmp, str << "0\r\n\r\n")
+    assert_predicate @hp, :body_eof?
+    assert_equal "", tmp
+    assert_same req, @hp.request(@env, str)
+    assert_equal "", str
+  end
+
+  def test_two_chunks
+    str = "PUT / HTTP/1.1\r\ntransfer-Encoding: chunked\r\n\r\n"
+    req = @hp.request(@env, str)
+    assert_same req, @env
+    assert_equal 0, str.size
+    tmp = ""
+    assert_nil @hp.filter_body(tmp, str << "6")
+    assert_equal 0, tmp.size
+    assert_nil @hp.filter_body(tmp, str << "\r\n")
+    assert_equal "", str
+    assert_equal 0, tmp.size
+    tmp = ""
+    assert_nil @hp.filter_body(tmp, str << "..")
+    assert_equal 2, tmp.size
+    assert_equal "..", tmp
+    assert_nil @hp.filter_body(tmp, str << "abcd\r\n1")
+    assert_equal "abcd", tmp
+    assert_nil @hp.filter_body(tmp, str << "\r")
+    assert_equal "", tmp
+    assert_nil @hp.filter_body(tmp, str << "\n")
+    assert_equal "", tmp
+    assert_nil @hp.filter_body(tmp, str << "z")
+    assert_equal "z", tmp
+    assert_nil @hp.filter_body(tmp, str << "\r\n")
+    assert_nil @hp.filter_body(tmp, str << "0")
+    assert_nil @hp.filter_body(tmp, str << "\r")
+    rv = @hp.filter_body(tmp, str << "\nGET")
+    assert_equal "GET", str
+    assert_same tmp, rv
+    assert_equal '', tmp
+    assert_not_predicate @hp, :keepalive?
+  end
+
+  def test_big_chunk
+    str = "PUT / HTTP/1.1\r\ntransfer-Encoding: chunked\r\n\r\n" \
+          "4000\r\nabcd"
+    req = @hp.request(@env, str)
+    tmp = ''
+    assert_nil @hp.filter_body(tmp, str)
+    assert_equal '', str
+    str << ' ' * 16300
+    assert_nil @hp.filter_body(tmp, str)
+    assert_equal '', str
+    str << ' ' * 80
+    assert_nil @hp.filter_body(tmp, str)
+    assert_equal '', str
+    assert_not_predicate @hp, :body_eof?
+    assert_same tmp, @hp.filter_body(tmp, str << "\r\n0\r\n")
+    assert_equal "", tmp
+    assert_predicate @hp, :body_eof?
+    str << "\r\n"
+    assert_same req, @hp.request(@env, str)
+    assert_equal "", str
+    assert_predicate @hp, :body_eof?
+    assert_predicate @hp, :keepalive?
+  end
+
+  def test_two_chunks_oneshot
+    str = "PUT / HTTP/1.1\r\ntransfer-Encoding: chunked\r\n\r\n" \
+           "1\r\na\r\n2\r\n..\r\n0\r\n"
+    req = @hp.request(@env, str)
+    assert_same req, @env
+    tmp = ''
+    assert_nil @hp.filter_body(tmp, str)
+    assert_equal 'a..', tmp
+    assert_same tmp, @hp.filter_body(tmp, str)
+    assert_not_predicate @hp, :keepalive?
+  end
+
+  def test_chunks_bytewise
+    chunked = "10\r\nabcdefghijklmnop\r\n11\r\n0123456789abcdefg\r\n0\r\n"
+    str = "PUT / HTTP/1.1\r\ntransfer-Encoding: chunked\r\n\r\n"
+    buf = str.dup
+    req = @hp.request(@env, buf)
+    assert_same req, @env
+    assert_equal "", buf
+    tmp = ''
+    body = ''
+    str = chunked[0..-2]
+    str.each_byte { |byte|
+      assert_nil @hp.filter_body(tmp, buf << byte.chr)
+      body << tmp
+    }
+    assert_equal 'abcdefghijklmnop0123456789abcdefg', body
+    assert_same tmp, @hp.filter_body(tmp, buf << "\n")
+    assert_not_predicate @hp, :keepalive?
+  end
+
+  def test_trailers
+    str = "PUT / HTTP/1.1\r\n" \
+           "Trailer: Content-MD5\r\n" \
+           "transfer-Encoding: chunked\r\n\r\n" \
+           "1\r\na\r\n2\r\n..\r\n0\r\n"
+    req = @hp.request(@env, str)
+    assert_same req, @env
+    assert_equal 'Content-MD5', req['HTTP_TRAILER']
+    assert_nil req['HTTP_CONTENT_MD5']
+    tmp = ''
+    assert_nil @hp.filter_body(tmp, str)
+    assert_equal 'a..', tmp
+    md5_b64 = [ Digest::MD5.digest(tmp) ].pack('m').strip.freeze
+    assert_same tmp, @hp.filter_body(tmp, str)
+    assert_equal '', str
+    md5_hdr = "Content-MD5: #{md5_b64}\r\n".freeze
+    str << md5_hdr
+    assert_nil @hp.request(@env, str)
+    assert_equal md5_b64, req['HTTP_CONTENT_MD5']
+    assert_equal "CONTENT_MD5: #{md5_b64}\r\n", str
+    str << "\r"
+    assert_nil @hp.request(@env, str)
+    str << "\nGET / "
+    req = @hp.request(@env, str)
+    assert_equal "GET / ", str
+    assert_predicate @hp, :keepalive?
+  end
+
+  def test_trailers_slowly
+    str = "PUT / HTTP/1.1\r\n" \
+           "Trailer: Content-MD5\r\n" \
+           "transfer-Encoding: chunked\r\n\r\n" \
+           "1\r\na\r\n2\r\n..\r\n0\r\n"
+    req = @hp.request(@env, str)
+    assert_equal 'Content-MD5', req['HTTP_TRAILER']
+    assert_nil req['HTTP_CONTENT_MD5']
+    tmp = ''
+    assert_nil @hp.filter_body(tmp, str)
+    assert_equal 'a..', tmp
+    md5_b64 = [ Digest::MD5.digest(tmp) ].pack('m').strip.freeze
+    assert_same tmp, @hp.filter_body(tmp, str)
+    assert_equal '', str
+    assert_nil @hp.request(req, str)
+    md5_hdr = "Content-MD5: #{md5_b64}\r\n".freeze
+    md5_hdr.each_byte { |byte|
+      str << byte.chr
+      assert_nil @hp.request(req, str)
+    }
+    assert_equal md5_b64, req['HTTP_CONTENT_MD5']
+    assert_equal "CONTENT_MD5: #{md5_b64}\r\n", str
+    str << "\r"
+    assert_nil @hp.request(@env, str)
+    str << "\n"
+    assert_same req, @hp.request(@env, str)
+  end
+
+  def test_max_chunk
+    assert_operator Kcar::Parser::CHUNK_MAX, :>=, 0xffff
+    str = "PUT / HTTP/1.1\r\n" \
+           "transfer-Encoding: chunked\r\n\r\n" \
+           "#{Kcar::Parser::CHUNK_MAX.to_s(16)}\r\na\r\n2\r\n..\r\n0\r\n"
+    req = @hp.request(@env, str)
+    assert_same req, @env
+    assert_nil @hp.body_bytes_left
+    assert_nil @hp.filter_body('', str)
+    assert_not_predicate @hp, :keepalive?
+  end
+
+  def test_max_body
+    n = Kcar::Parser::LENGTH_MAX
+    buf = "PUT / HTTP/1.1\r\nContent-Length: #{n}\r\n\r\n"
+    req = @hp.request(@env, buf)
+    assert_equal n, req['CONTENT_LENGTH'].to_i
+    # connection can only be persistent when body is drained:
+    assert_not_predicate @hp, :keepalive?
+    @hp.body_bytes_left = 1
+    assert_not_predicate @hp, :keepalive?
+    @hp.body_bytes_left = 0
+    assert_predicate @hp, :keepalive?
+  end
+
+  def test_overflow_chunk
+    n = Kcar::Parser::CHUNK_MAX + 1
+    str = "PUT / HTTP/1.1\r\n" \
+           "transfer-Encoding: chunked\r\n\r\n" \
+           "#{n.to_s(16)}\r\na\r\n2\r\n..\r\n0\r\n"
+    req = @hp.request(@env, str)
+    assert_nil @hp.body_bytes_left
+    assert_equal 'chunked', req['HTTP_TRANSFER_ENCODING']
+    assert_raise(Kcar::ParserError) { @hp.filter_body('', str) }
+  end
+
+  def test_overflow_content_length
+    n = Kcar::Parser::LENGTH_MAX + 1
+    buf ="PUT / HTTP/1.1\r\nContent-Length: #{n}\r\n\r\n"
+    assert_raise(Kcar::ParserError) do
+      @hp.request(@env, buf)
+    end
+  end
+
+  def test_bad_chunk
+    buf = "PUT / HTTP/1.1\r\n" \
+          "transfer-Encoding: chunked\r\n\r\n" \
+          "#zzz\r\na\r\n2\r\n..\r\n0\r\n"
+    @hp.request(@env, buf)
+    assert_nil @hp.body_bytes_left
+    assert_raise(Kcar::ParserError) { @hp.filter_body("", buf) }
+  end
+
+  def test_bad_content_length
+    buf = "PUT / HTTP/1.1\r\nContent-Length: 7ff\r\n\r\n"
+    assert_raise(Kcar::ParserError) { @hp.request(@env, buf) }
+  end
+
+  def test_bad_trailers
+    str = "PUT / HTTP/1.1\r\n" \
+           "Trailer: Transfer-Encoding\r\n" \
+           "transfer-Encoding: chunked\r\n\r\n" \
+           "1\r\na\r\n2\r\n..\r\n0\r\n"
+    req = @hp.request(@env, str)
+    assert_equal 'Transfer-Encoding', req['HTTP_TRAILER']
+    tmp = ''
+    assert_nil @hp.filter_body(tmp, str)
+    assert_equal 'a..', tmp
+    assert_equal '', str
+    str << "Transfer-Encoding: identity\r\n\r\n"
+    assert_raise(Kcar::ParserError) { @hp.request(@env, str) }
+  end
+end