webrick 1.3.1

data/test/webrick/test_httpauth.rb

@@ -0,0 +1,167 @@
+require "test/unit"
+require "net/http"
+require "tempfile"
+require "webrick"
+require "webrick/httpauth/basicauth"
+require_relative "utils"
+
+class TestWEBrickHTTPAuth < Test::Unit::TestCase
+  def test_basic_auth
+    TestWEBrick.start_httpserver{|server, addr, port, log|
+      realm = "WEBrick's realm"
+      path = "/basic_auth"
+
+      server.mount_proc(path){|req, res|
+        WEBrick::HTTPAuth.basic_auth(req, res, realm){|user, pass|
+          user == "webrick" && pass == "supersecretpassword"
+        }
+        res.body = "hoge"
+      }
+      http = Net::HTTP.new(addr, port)
+      g = Net::HTTP::Get.new(path)
+      g.basic_auth("webrick", "supersecretpassword")
+      http.request(g){|res| assert_equal("hoge", res.body, log.call)}
+      g.basic_auth("webrick", "not super")
+      http.request(g){|res| assert_not_equal("hoge", res.body, log.call)}
+    }
+  end
+
+  def test_basic_auth2
+    TestWEBrick.start_httpserver{|server, addr, port, log|
+      realm = "WEBrick's realm"
+      path = "/basic_auth2"
+
+      tmpfile = Tempfile.new("test_webrick_auth")
+      tmpfile.close
+      tmp_pass = WEBrick::HTTPAuth::Htpasswd.new(tmpfile.path)
+      tmp_pass.set_passwd(realm, "webrick", "supersecretpassword")
+      tmp_pass.set_passwd(realm, "foo", "supersecretpassword")
+      tmp_pass.flush
+
+      htpasswd = WEBrick::HTTPAuth::Htpasswd.new(tmpfile.path)
+      users = []
+      htpasswd.each{|user, pass| users << user }
+      assert_equal(2, users.size, log.call)
+      assert(users.member?("webrick"), log.call)
+      assert(users.member?("foo"), log.call)
+
+      server.mount_proc(path){|req, res|
+        auth = WEBrick::HTTPAuth::BasicAuth.new(
+          :Realm => realm, :UserDB => htpasswd,
+          :Logger => server.logger
+        )
+        auth.authenticate(req, res)
+        res.body = "hoge"
+      }
+      http = Net::HTTP.new(addr, port)
+      g = Net::HTTP::Get.new(path)
+      g.basic_auth("webrick", "supersecretpassword")
+      http.request(g){|res| assert_equal("hoge", res.body, log.call)}
+      g.basic_auth("webrick", "not super")
+      http.request(g){|res| assert_not_equal("hoge", res.body, log.call)}
+    }
+  end
+
+  def test_basic_auth3
+    tmpfile = Tempfile.new("test_webrick_auth")
+    tmpfile.puts("webrick:{SHA}GJYFRpBbdchp595jlh3Bhfmgp8k=")
+    tmpfile.flush
+    assert_raise(NotImplementedError){
+      WEBrick::HTTPAuth::Htpasswd.new(tmpfile.path)
+    }
+    tmpfile.close(true)
+
+    tmpfile = Tempfile.new("test_webrick_auth")
+    tmpfile.puts("webrick:$apr1$IOVMD/..$rmnOSPXr0.wwrLPZHBQZy0")
+    tmpfile.flush
+    assert_raise(NotImplementedError){
+      WEBrick::HTTPAuth::Htpasswd.new(tmpfile.path)
+    }
+    tmpfile.close(true)
+  end
+
+  DIGESTRES_ = /
+    ([a-zA-z\-]+)
+      [\s\t]*(?:\r\n[\s\t]*)*
+      =
+      [\s\t]*(?:\r\n[\s\t]*)*
+      (?:
+       "((?:[^"]+|\\[\x00-\x7F])*)" |
+       ([!\#$%&'*+\-.0-9A-Z^_`a-z|~]+)
+      )/x
+
+  def test_digest_auth
+    TestWEBrick.start_httpserver{|server, addr, port, log|
+      realm = "WEBrick's realm"
+      path = "/digest_auth"
+
+      tmpfile = Tempfile.new("test_webrick_auth")
+      tmpfile.close
+      tmp_pass = WEBrick::HTTPAuth::Htdigest.new(tmpfile.path)
+      tmp_pass.set_passwd(realm, "webrick", "supersecretpassword")
+      tmp_pass.set_passwd(realm, "foo", "supersecretpassword")
+      tmp_pass.flush
+
+      htdigest = WEBrick::HTTPAuth::Htdigest.new(tmpfile.path)
+      users = []
+      htdigest.each{|user, pass| users << user }
+      assert_equal(2, users.size, log.call)
+      assert(users.member?("webrick"), log.call)
+      assert(users.member?("foo"), log.call)
+
+      auth = WEBrick::HTTPAuth::DigestAuth.new(
+        :Realm => realm, :UserDB => htdigest,
+        :Algorithm => 'MD5',
+        :Logger => server.logger
+      )
+      server.mount_proc(path){|req, res|
+        auth.authenticate(req, res)
+        res.body = "hoge"
+      }
+
+      Net::HTTP.start(addr, port) do |http|
+        g = Net::HTTP::Get.new(path)
+        params = {}
+        http.request(g) do |res|
+          assert_equal('401', res.code, log.call)
+          res["www-authenticate"].scan(DIGESTRES_) do |key, quoted, token|
+            params[key.downcase] = token || quoted.delete('\\')
+          end
+           params['uri'] = "http://#{addr}:#{port}#{path}"
+        end
+
+        g['Authorization'] = credentials_for_request('webrick', "supersecretpassword", params)
+        http.request(g){|res| assert_equal("hoge", res.body, log.call)}
+
+        params['algorithm'].downcase! #4936
+        g['Authorization'] = credentials_for_request('webrick', "supersecretpassword", params)
+        http.request(g){|res| assert_equal("hoge", res.body, log.call)}
+
+        g['Authorization'] = credentials_for_request('webrick', "not super", params)
+        http.request(g){|res| assert_not_equal("hoge", res.body, log.call)}
+      end
+    }
+  end
+
+  private
+  def credentials_for_request(user, password, params)
+    cnonce = "hoge"
+    nonce_count = 1
+    ha1 = "#{user}:#{params['realm']}:#{password}"
+    ha2 = "GET:#{params['uri']}"
+    request_digest =
+      "#{Digest::MD5.hexdigest(ha1)}:" \
+      "#{params['nonce']}:#{'%08x' % nonce_count}:#{cnonce}:#{params['qop']}:" \
+      "#{Digest::MD5.hexdigest(ha2)}"
+    "Digest username=\"#{user}\"" \
+      ", realm=\"#{params['realm']}\"" \
+      ", nonce=\"#{params['nonce']}\"" \
+      ", uri=\"#{params['uri']}\"" \
+      ", qop=#{params['qop']}" \
+      ", nc=#{'%08x' % nonce_count}" \
+      ", cnonce=\"#{cnonce}\"" \
+      ", response=\"#{Digest::MD5.hexdigest(request_digest)}\"" \
+      ", opaque=\"#{params['opaque']}\"" \
+      ", algorithm=#{params['algorithm']}"
+  end
+end

data/test/webrick/test_httpproxy.rb

@@ -0,0 +1,282 @@
+require "test/unit"
+require "net/http"
+require "webrick"
+require "webrick/httpproxy"
+begin
+  require "webrick/ssl"
+  require "net/https"
+  require File.expand_path("../openssl/utils.rb", File.dirname(__FILE__))
+rescue LoadError
+  # test_connect will be skipped
+end
+require File.expand_path("utils.rb", File.dirname(__FILE__))
+
+class TestWEBrickHTTPProxy < Test::Unit::TestCase
+  def test_fake_proxy
+    assert_nil(WEBrick::FakeProxyURI.scheme)
+    assert_nil(WEBrick::FakeProxyURI.host)
+    assert_nil(WEBrick::FakeProxyURI.port)
+    assert_nil(WEBrick::FakeProxyURI.path)
+    assert_nil(WEBrick::FakeProxyURI.userinfo)
+    assert_raise(NoMethodError){ WEBrick::FakeProxyURI.foo }
+  end
+
+  def test_proxy
+    # Testing GET or POST to the proxy server
+    # Note that the proxy server works as the origin server.
+    #                    +------+
+    #                    V      |
+    #  client -------> proxy ---+
+    #        GET / POST     GET / POST
+    #
+    proxy_handler_called = request_handler_called = 0
+    config = {
+      :ServerName => "localhost.localdomain",
+      :ProxyContentHandler => Proc.new{|req, res| proxy_handler_called += 1 },
+      :RequestCallback => Proc.new{|req, res| request_handler_called += 1 }
+    }
+    TestWEBrick.start_httpproxy(config){|server, addr, port, log|
+      server.mount_proc("/"){|req, res|
+        res.body = "#{req.request_method} #{req.path} #{req.body}"
+      }
+      http = Net::HTTP.new(addr, port, addr, port)
+
+      req = Net::HTTP::Get.new("/")
+      http.request(req){|res|
+        assert_equal("1.1 localhost.localdomain:#{port}", res["via"], log.call)
+        assert_equal("GET / ", res.body, log.call)
+      }
+      assert_equal(1, proxy_handler_called, log.call)
+      assert_equal(2, request_handler_called, log.call)
+
+      req = Net::HTTP::Head.new("/")
+      http.request(req){|res|
+        assert_equal("1.1 localhost.localdomain:#{port}", res["via"], log.call)
+        assert_nil(res.body, log.call)
+      }
+      assert_equal(2, proxy_handler_called, log.call)
+      assert_equal(4, request_handler_called, log.call)
+
+      req = Net::HTTP::Post.new("/")
+      req.body = "post-data"
+      http.request(req){|res|
+        assert_equal("1.1 localhost.localdomain:#{port}", res["via"], log.call)
+        assert_equal("POST / post-data", res.body, log.call)
+      }
+      assert_equal(3, proxy_handler_called, log.call)
+      assert_equal(6, request_handler_called, log.call)
+    }
+  end
+
+  def test_no_proxy
+    # Testing GET or POST to the proxy server without proxy request.
+    #
+    #  client -------> proxy
+    #        GET / POST
+    #
+    proxy_handler_called = request_handler_called = 0
+    config = {
+      :ServerName => "localhost.localdomain",
+      :ProxyContentHandler => Proc.new{|req, res| proxy_handler_called += 1 },
+      :RequestCallback => Proc.new{|req, res| request_handler_called += 1 }
+    }
+    TestWEBrick.start_httpproxy(config){|server, addr, port, log|
+      server.mount_proc("/"){|req, res|
+        res.body = "#{req.request_method} #{req.path} #{req.body}"
+      }
+      http = Net::HTTP.new(addr, port)
+
+      req = Net::HTTP::Get.new("/")
+      http.request(req){|res|
+        assert_nil(res["via"], log.call)
+        assert_equal("GET / ", res.body, log.call)
+      }
+      assert_equal(0, proxy_handler_called, log.call)
+      assert_equal(1, request_handler_called, log.call)
+
+      req = Net::HTTP::Head.new("/")
+      http.request(req){|res|
+        assert_nil(res["via"], log.call)
+        assert_nil(res.body, log.call)
+      }
+      assert_equal(0, proxy_handler_called, log.call)
+      assert_equal(2, request_handler_called, log.call)
+
+      req = Net::HTTP::Post.new("/")
+      req.body = "post-data"
+      http.request(req){|res|
+        assert_nil(res["via"], log.call)
+        assert_equal("POST / post-data", res.body, log.call)
+      }
+      assert_equal(0, proxy_handler_called, log.call)
+      assert_equal(3, request_handler_called, log.call)
+    }
+  end
+
+  def make_certificate(key, cn)
+    subject = OpenSSL::X509::Name.parse("/DC=org/DC=ruby-lang/CN=#{cn}")
+    exts = [
+      ["keyUsage", "keyEncipherment,digitalSignature", true],
+    ]
+    cert = OpenSSL::TestUtils.issue_cert(
+      subject, key, 1, Time.now, Time.now + 3600, exts,
+      nil, nil, OpenSSL::Digest::SHA1.new
+    )
+    return cert
+  end
+
+  def test_connect
+    # Testing CONNECT to proxy server
+    #
+    #  client -----------> proxy -----------> https
+    #    1.     CONNECT          establish TCP
+    #    2.   ---- establish SSL session --->
+    #    3.   ------- GET or POST ---------->
+    #
+    key = OpenSSL::TestUtils::TEST_KEY_RSA1024
+    cert = make_certificate(key, "127.0.0.1")
+    s_config = {
+      :SSLEnable =>true,
+      :ServerName => "localhost",
+      :SSLCertificate => cert,
+      :SSLPrivateKey => key,
+    }
+    config = {
+      :ServerName => "localhost.localdomain",
+      :RequestCallback => Proc.new{|req, res|
+        assert_equal("CONNECT", req.request_method)
+      },
+    }
+    TestWEBrick.start_httpserver(s_config){|s_server, s_addr, s_port, s_log|
+      s_server.mount_proc("/"){|req, res|
+        res.body = "SSL #{req.request_method} #{req.path} #{req.body}"
+      }
+      TestWEBrick.start_httpproxy(config){|server, addr, port, log|
+        http = Net::HTTP.new("127.0.0.1", s_port, addr, port)
+        http.use_ssl = true
+        http.verify_callback = Proc.new do |preverify_ok, store_ctx|
+          store_ctx.current_cert.to_der == cert.to_der
+        end
+
+        req = Net::HTTP::Get.new("/")
+        http.request(req){|res|
+          assert_equal("SSL GET / ", res.body, s_log.call + log.call)
+        }
+
+        req = Net::HTTP::Post.new("/")
+        req.body = "post-data"
+        http.request(req){|res|
+          assert_equal("SSL POST / post-data", res.body, s_log.call + log.call)
+        }
+      }
+    }
+  end if defined?(OpenSSL)
+
+  def test_upstream_proxy
+    # Testing GET or POST through the upstream proxy server
+    # Note that the upstream proxy server works as the origin server.
+    #                                   +------+
+    #                                   V      |
+    #  client -------> proxy -------> proxy ---+
+    #        GET / POST     GET / POST     GET / POST
+    #
+    up_proxy_handler_called = up_request_handler_called = 0
+    proxy_handler_called = request_handler_called = 0
+    up_config = {
+      :ServerName => "localhost.localdomain",
+      :ProxyContentHandler => Proc.new{|req, res| up_proxy_handler_called += 1},
+      :RequestCallback => Proc.new{|req, res| up_request_handler_called += 1}
+    }
+    TestWEBrick.start_httpproxy(up_config){|up_server, up_addr, up_port, up_log|
+      up_server.mount_proc("/"){|req, res|
+        res.body = "#{req.request_method} #{req.path} #{req.body}"
+      }
+      config = {
+        :ServerName => "localhost.localdomain",
+        :ProxyURI => URI.parse("http://localhost:#{up_port}"),
+        :ProxyContentHandler => Proc.new{|req, res| proxy_handler_called += 1},
+        :RequestCallback => Proc.new{|req, res| request_handler_called += 1},
+      }
+      TestWEBrick.start_httpproxy(config){|server, addr, port, log|
+        http = Net::HTTP.new(up_addr, up_port, addr, port)
+
+        req = Net::HTTP::Get.new("/")
+        http.request(req){|res|
+          skip res.message unless res.code == '200'
+          via = res["via"].split(/,\s+/)
+          assert(via.include?("1.1 localhost.localdomain:#{up_port}"), up_log.call + log.call)
+          assert(via.include?("1.1 localhost.localdomain:#{port}"), up_log.call + log.call)
+          assert_equal("GET / ", res.body)
+        }
+        assert_equal(1, up_proxy_handler_called, up_log.call + log.call)
+        assert_equal(2, up_request_handler_called, up_log.call + log.call)
+        assert_equal(1, proxy_handler_called, up_log.call + log.call)
+        assert_equal(1, request_handler_called, up_log.call + log.call)
+
+        req = Net::HTTP::Head.new("/")
+        http.request(req){|res|
+          via = res["via"].split(/,\s+/)
+          assert(via.include?("1.1 localhost.localdomain:#{up_port}"), up_log.call + log.call)
+          assert(via.include?("1.1 localhost.localdomain:#{port}"), up_log.call + log.call)
+          assert_nil(res.body, up_log.call + log.call)
+        }
+        assert_equal(2, up_proxy_handler_called, up_log.call + log.call)
+        assert_equal(4, up_request_handler_called, up_log.call + log.call)
+        assert_equal(2, proxy_handler_called, up_log.call + log.call)
+        assert_equal(2, request_handler_called, up_log.call + log.call)
+
+        req = Net::HTTP::Post.new("/")
+        req.body = "post-data"
+        http.request(req){|res|
+          via = res["via"].split(/,\s+/)
+          assert(via.include?("1.1 localhost.localdomain:#{up_port}"), up_log.call + log.call)
+          assert(via.include?("1.1 localhost.localdomain:#{port}"), up_log.call + log.call)
+          assert_equal("POST / post-data", res.body, up_log.call + log.call)
+        }
+        assert_equal(3, up_proxy_handler_called, up_log.call + log.call)
+        assert_equal(6, up_request_handler_called, up_log.call + log.call)
+        assert_equal(3, proxy_handler_called, up_log.call + log.call)
+        assert_equal(3, request_handler_called, up_log.call + log.call)
+
+        if defined?(OpenSSL)
+          # Testing CONNECT to the upstream proxy server
+          #
+          #  client -------> proxy -------> proxy -------> https
+          #    1.   CONNECT        CONNECT      establish TCP
+          #    2.   -------- establish SSL session ------>
+          #    3.   ---------- GET or POST -------------->
+          #
+          key = OpenSSL::TestUtils::TEST_KEY_RSA1024
+          cert = make_certificate(key, "127.0.0.1")
+          s_config = {
+            :SSLEnable =>true,
+            :ServerName => "localhost",
+            :SSLCertificate => cert,
+            :SSLPrivateKey => key,
+          }
+          TestWEBrick.start_httpserver(s_config){|s_server, s_addr, s_port, s_log|
+            s_server.mount_proc("/"){|req2, res|
+              res.body = "SSL #{req2.request_method} #{req2.path} #{req2.body}"
+            }
+            http = Net::HTTP.new("127.0.0.1", s_port, addr, port, up_log.call + log.call + s_log.call)
+            http.use_ssl = true
+            http.verify_callback = Proc.new do |preverify_ok, store_ctx|
+              store_ctx.current_cert.to_der == cert.to_der
+            end
+
+            req2 = Net::HTTP::Get.new("/")
+            http.request(req2){|res|
+              assert_equal("SSL GET / ", res.body, up_log.call + log.call + s_log.call)
+            }
+
+            req2 = Net::HTTP::Post.new("/")
+            req2.body = "post-data"
+            http.request(req2){|res|
+              assert_equal("SSL POST / post-data", res.body, up_log.call + log.call + s_log.call)
+            }
+          }
+        end
+      }
+    }
+  end
+end

data/test/webrick/test_httprequest.rb

@@ -0,0 +1,411 @@
+require "webrick"
+require "stringio"
+require "test/unit"
+
+class TestWEBrickHTTPRequest < Test::Unit::TestCase
+  def test_simple_request
+    msg = <<-_end_of_message_
+GET /
+    _end_of_message_
+    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+    req.parse(StringIO.new(msg))
+    assert(req.meta_vars) # fails if @header was not initialized and iteration is attempted on the nil reference
+  end
+
+  def test_parse_09
+    msg = <<-_end_of_message_
+      GET /
+      foobar    # HTTP/0.9 request don't have header nor entity body.
+    _end_of_message_
+    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+    req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
+    assert_equal("GET", req.request_method)
+    assert_equal("/", req.unparsed_uri)
+    assert_equal(WEBrick::HTTPVersion.new("0.9"), req.http_version)
+    assert_equal(WEBrick::Config::HTTP[:ServerName], req.host)
+    assert_equal(80, req.port)
+    assert_equal(false, req.keep_alive?)
+    assert_equal(nil, req.body)
+    assert(req.query.empty?)
+  end
+
+  def test_parse_10
+    msg = <<-_end_of_message_
+      GET / HTTP/1.0
+
+    _end_of_message_
+    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+    req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
+    assert_equal("GET", req.request_method)
+    assert_equal("/", req.unparsed_uri)
+    assert_equal(WEBrick::HTTPVersion.new("1.0"), req.http_version)
+    assert_equal(WEBrick::Config::HTTP[:ServerName], req.host)
+    assert_equal(80, req.port)
+    assert_equal(false, req.keep_alive?)
+    assert_equal(nil, req.body)
+    assert(req.query.empty?)
+  end
+
+  def test_parse_11
+    msg = <<-_end_of_message_
+      GET /path HTTP/1.1
+
+    _end_of_message_
+    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+    req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
+    assert_equal("GET", req.request_method)
+    assert_equal("/path", req.unparsed_uri)
+    assert_equal("", req.script_name)
+    assert_equal("/path", req.path_info)
+    assert_equal(WEBrick::HTTPVersion.new("1.1"), req.http_version)
+    assert_equal(WEBrick::Config::HTTP[:ServerName], req.host)
+    assert_equal(80, req.port)
+    assert_equal(true, req.keep_alive?)
+    assert_equal(nil, req.body)
+    assert(req.query.empty?)
+  end
+
+  def test_request_uri_too_large
+    msg = <<-_end_of_message_
+      GET /#{"a"*2084} HTTP/1.1
+    _end_of_message_
+    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+    assert_raise(WEBrick::HTTPStatus::RequestURITooLarge){
+      req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
+    }
+  end
+
+  def test_parse_headers
+    msg = <<-_end_of_message_
+      GET /path HTTP/1.1
+      Host: test.ruby-lang.org:8080
+      Connection: close
+      Accept: text/*;q=0.3, text/html;q=0.7, text/html;level=1,
+              text/html;level=2;q=0.4, */*;q=0.5
+      Accept-Encoding: compress;q=0.5
+      Accept-Encoding: gzip;q=1.0, identity; q=0.4, *;q=0
+      Accept-Language: en;q=0.5, *; q=0
+      Accept-Language: ja
+      Content-Type: text/plain
+      Content-Length: 7
+      X-Empty-Header:
+
+      foobar
+    _end_of_message_
+    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+    req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
+    assert_equal(
+      URI.parse("http://test.ruby-lang.org:8080/path"), req.request_uri)
+    assert_equal("test.ruby-lang.org", req.host)
+    assert_equal(8080, req.port)
+    assert_equal(false, req.keep_alive?)
+    assert_equal(
+      %w(text/html;level=1 text/html */* text/html;level=2 text/*),
+      req.accept)
+    assert_equal(%w(gzip compress identity *), req.accept_encoding)
+    assert_equal(%w(ja en *), req.accept_language)
+    assert_equal(7, req.content_length)
+    assert_equal("text/plain", req.content_type)
+    assert_equal("foobar\n", req.body)
+    assert_equal("", req["x-empty-header"])
+    assert_equal(nil, req["x-no-header"])
+    assert(req.query.empty?)
+  end
+
+  def test_parse_header2()
+    msg = <<-_end_of_message_
+      POST /foo/bar/../baz?q=a HTTP/1.0
+      Content-Length: 9
+      User-Agent:
+        FOO   BAR
+        BAZ
+
+      hogehoge
+    _end_of_message_
+    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+    req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
+    assert_equal("POST", req.request_method)
+    assert_equal("/foo/baz", req.path)
+    assert_equal("", req.script_name)
+    assert_equal("/foo/baz", req.path_info)
+    assert_equal("9", req['content-length'])
+    assert_equal("FOO BAR BAZ", req['user-agent'])
+    assert_equal("hogehoge\n", req.body)
+  end
+
+  def test_parse_headers3
+    msg = <<-_end_of_message_
+      GET /path HTTP/1.1
+      Host: test.ruby-lang.org
+
+    _end_of_message_
+    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+    req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
+    assert_equal(URI.parse("http://test.ruby-lang.org/path"), req.request_uri)
+    assert_equal("test.ruby-lang.org", req.host)
+    assert_equal(80, req.port)
+
+    msg = <<-_end_of_message_
+      GET /path HTTP/1.1
+      Host: 192.168.1.1
+
+    _end_of_message_
+    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+    req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
+    assert_equal(URI.parse("http://192.168.1.1/path"), req.request_uri)
+    assert_equal("192.168.1.1", req.host)
+    assert_equal(80, req.port)
+
+    msg = <<-_end_of_message_
+      GET /path HTTP/1.1
+      Host: [fe80::208:dff:feef:98c7]
+
+    _end_of_message_
+    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+    req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
+    assert_equal(URI.parse("http://[fe80::208:dff:feef:98c7]/path"),
+                 req.request_uri)
+    assert_equal("[fe80::208:dff:feef:98c7]", req.host)
+    assert_equal(80, req.port)
+
+    msg = <<-_end_of_message_
+      GET /path HTTP/1.1
+      Host: 192.168.1.1:8080
+
+    _end_of_message_
+    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+    req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
+    assert_equal(URI.parse("http://192.168.1.1:8080/path"), req.request_uri)
+    assert_equal("192.168.1.1", req.host)
+    assert_equal(8080, req.port)
+
+    msg = <<-_end_of_message_
+      GET /path HTTP/1.1
+      Host: [fe80::208:dff:feef:98c7]:8080
+
+    _end_of_message_
+    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+    req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
+    assert_equal(URI.parse("http://[fe80::208:dff:feef:98c7]:8080/path"),
+                 req.request_uri)
+    assert_equal("[fe80::208:dff:feef:98c7]", req.host)
+    assert_equal(8080, req.port)
+  end
+
+  def test_parse_get_params
+    param = "foo=1;foo=2;foo=3;bar=x"
+    msg = <<-_end_of_message_
+      GET /path?#{param} HTTP/1.1
+      Host: test.ruby-lang.org:8080
+
+    _end_of_message_
+    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+    req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
+    query = req.query
+    assert_equal("1", query["foo"])
+    assert_equal(["1", "2", "3"], query["foo"].to_ary)
+    assert_equal(["1", "2", "3"], query["foo"].list)
+    assert_equal("x", query["bar"])
+    assert_equal(["x"], query["bar"].list)
+  end
+
+  def test_parse_post_params
+    param = "foo=1;foo=2;foo=3;bar=x"
+    msg = <<-_end_of_message_
+      POST /path?foo=x;foo=y;foo=z;bar=1 HTTP/1.1
+      Host: test.ruby-lang.org:8080
+      Content-Length: #{param.size}
+      Content-Type: application/x-www-form-urlencoded
+
+      #{param}
+    _end_of_message_
+    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+    req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
+    query = req.query
+    assert_equal("1", query["foo"])
+    assert_equal(["1", "2", "3"], query["foo"].to_ary)
+    assert_equal(["1", "2", "3"], query["foo"].list)
+    assert_equal("x", query["bar"])
+    assert_equal(["x"], query["bar"].list)
+  end
+
+  def test_chunked
+    crlf = "\x0d\x0a"
+    msg = <<-_end_of_message_
+      POST /path HTTP/1.1
+      Host: test.ruby-lang.org:8080
+      Transfer-Encoding: chunked
+
+    _end_of_message_
+    msg.gsub!(/^ {6}/, "")
+    open(__FILE__){|io|
+      while chunk = io.read(100)
+        msg << chunk.size.to_s(16) << crlf
+        msg << chunk << crlf
+      end
+    }
+    msg << "0" << crlf
+    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+    req.parse(StringIO.new(msg))
+    assert_equal(File.read(__FILE__), req.body)
+  end
+
+  def test_forwarded
+    msg = <<-_end_of_message_
+      GET /foo HTTP/1.1
+      Host: localhost:10080
+      User-Agent: w3m/0.5.2
+      X-Forwarded-For: 123.123.123.123
+      X-Forwarded-Host: forward.example.com
+      X-Forwarded-Server: server.example.com
+      Connection: Keep-Alive
+
+    _end_of_message_
+    msg.gsub!(/^ {6}/, "")
+    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+    req.parse(StringIO.new(msg))
+    assert_equal("server.example.com", req.server_name)
+    assert_equal("http://forward.example.com/foo", req.request_uri.to_s)
+    assert_equal("forward.example.com", req.host)
+    assert_equal(80, req.port)
+    assert_equal("123.123.123.123", req.remote_ip)
+    assert(!req.ssl?)
+
+    msg = <<-_end_of_message_
+      GET /foo HTTP/1.1
+      Host: localhost:10080
+      User-Agent: w3m/0.5.2
+      X-Forwarded-For: 192.168.1.10, 172.16.1.1, 123.123.123.123
+      X-Forwarded-Host: forward.example.com:8080
+      X-Forwarded-Server: server.example.com
+      Connection: Keep-Alive
+
+    _end_of_message_
+    msg.gsub!(/^ {6}/, "")
+    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+    req.parse(StringIO.new(msg))
+    assert_equal("server.example.com", req.server_name)
+    assert_equal("http://forward.example.com:8080/foo", req.request_uri.to_s)
+    assert_equal("forward.example.com", req.host)
+    assert_equal(8080, req.port)
+    assert_equal("123.123.123.123", req.remote_ip)
+    assert(!req.ssl?)
+
+    msg = <<-_end_of_message_
+      GET /foo HTTP/1.1
+      Host: localhost:10080
+      Client-IP: 234.234.234.234
+      X-Forwarded-Proto: https
+      X-Forwarded-For: 192.168.1.10, 10.0.0.1, 123.123.123.123
+      X-Forwarded-Host: forward.example.com
+      X-Forwarded-Server: server.example.com
+      X-Requested-With: XMLHttpRequest
+      Connection: Keep-Alive
+
+    _end_of_message_
+    msg.gsub!(/^ {6}/, "")
+    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+    req.parse(StringIO.new(msg))
+    assert_equal("server.example.com", req.server_name)
+    assert_equal("https://forward.example.com/foo", req.request_uri.to_s)
+    assert_equal("forward.example.com", req.host)
+    assert_equal(443, req.port)
+    assert_equal("234.234.234.234", req.remote_ip)
+    assert(req.ssl?)
+
+    msg = <<-_end_of_message_
+      GET /foo HTTP/1.1
+      Host: localhost:10080
+      Client-IP: 234.234.234.234
+      X-Forwarded-Proto: https
+      X-Forwarded-For: 192.168.1.10
+      X-Forwarded-Host: forward1.example.com:1234, forward2.example.com:5678
+      X-Forwarded-Server: server1.example.com, server2.example.com
+      X-Requested-With: XMLHttpRequest
+      Connection: Keep-Alive
+
+    _end_of_message_
+    msg.gsub!(/^ {6}/, "")
+    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+    req.parse(StringIO.new(msg))
+    assert_equal("server1.example.com", req.server_name)
+    assert_equal("https://forward1.example.com:1234/foo", req.request_uri.to_s)
+    assert_equal("forward1.example.com", req.host)
+    assert_equal(1234, req.port)
+    assert_equal("234.234.234.234", req.remote_ip)
+    assert(req.ssl?)
+  end
+
+  def test_continue_sent
+    msg = <<-_end_of_message_
+      POST /path HTTP/1.1
+      Expect: 100-continue
+
+    _end_of_message_
+    msg.gsub!(/^ {6}/, "")
+    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+    req.parse(StringIO.new(msg))
+    assert req['expect']
+    l = msg.size
+    req.continue
+    assert_not_equal l, msg.size
+    assert_match /HTTP\/1.1 100 continue\r\n\r\n\z/, msg
+    assert !req['expect']
+  end
+
+  def test_continue_not_sent
+    msg = <<-_end_of_message_
+      POST /path HTTP/1.1
+
+    _end_of_message_
+    msg.gsub!(/^ {6}/, "")
+    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+    req.parse(StringIO.new(msg))
+    assert !req['expect']
+    l = msg.size
+    req.continue
+    assert_equal l, msg.size
+  end
+
+  def test_bad_messages
+    param = "foo=1;foo=2;foo=3;bar=x"
+    msg = <<-_end_of_message_
+      POST /path?foo=x;foo=y;foo=z;bar=1 HTTP/1.1
+      Host: test.ruby-lang.org:8080
+      Content-Type: application/x-www-form-urlencoded
+
+      #{param}
+    _end_of_message_
+    assert_raise(WEBrick::HTTPStatus::LengthRequired){
+      req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+      req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
+      req.body
+    }
+
+    msg = <<-_end_of_message_
+      POST /path?foo=x;foo=y;foo=z;bar=1 HTTP/1.1
+      Host: test.ruby-lang.org:8080
+      Content-Length: 100000
+
+      body is too short.
+    _end_of_message_
+    assert_raise(WEBrick::HTTPStatus::BadRequest){
+      req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+      req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
+      req.body
+    }
+
+    msg = <<-_end_of_message_
+      POST /path?foo=x;foo=y;foo=z;bar=1 HTTP/1.1
+      Host: test.ruby-lang.org:8080
+      Transfer-Encoding: foobar
+
+      body is too short.
+    _end_of_message_
+    assert_raise(WEBrick::HTTPStatus::NotImplemented){
+      req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+      req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
+      req.body
+    }
+  end
+end