rubysl-webrick 1.0.0 → 2.0.0

data/lib/webrick/httpauth/userdb.rb

@@ -1,4 +1,4 @@
-#
+#--
 # httpauth/userdb.rb -- UserDB mix-in module.
 #
 # Author: IPR -- Internet Programming with Ruby -- writers
@@ -9,19 +9,42 @@
 
 module WEBrick
   module HTTPAuth
+
+    ##
+    # User database mixin for HTTPAuth.  This mixin dispatches user record
+    # access to the underlying auth_type for this database.
+
     module UserDB
-      attr_accessor :auth_type # BasicAuth or DigestAuth
+
+      ##
+      # The authentication type.
+      #
+      # WEBrick::HTTPAuth::BasicAuth or WEBrick::HTTPAuth::DigestAuth are
+      # built-in.
+
+      attr_accessor :auth_type
+
+      ##
+      # Creates an obscured password in +realm+ with +user+ and +password+
+      # using the auth_type of this database.
 
       def make_passwd(realm, user, pass)
         @auth_type::make_passwd(realm, user, pass)
       end
 
+      ##
+      # Sets a password in +realm+ with +user+ and +password+ for the
+      # auth_type of this database.
+
       def set_passwd(realm, user, pass)
         self[user] = pass
-      end                             
+      end
+
+      ##
+      # Retrieves a password in +realm+ for +user+ for the auth_type of this
+      # database.  +reload_db+ is a dummy value.
 
       def get_passwd(realm, user, reload_db=false)
-        # reload_db is dummy
         make_passwd(realm, user, self[user])
       end
     end

data/lib/webrick/httpproxy.rb

@@ -15,24 +15,83 @@ require "net/http"
 Net::HTTP::version_1_2 if RUBY_VERSION < "1.7"
 
 module WEBrick
-  NullReader = Object.new
-  class << NullReader
+
+  NullReader = Object.new # :nodoc:
+  class << NullReader # :nodoc:
     def read(*args)
       nil
     end
     alias gets read
   end
 
-  class HTTPProxyServer < HTTPServer
-    def initialize(config)
+  FakeProxyURI = Object.new # :nodoc:
+  class << FakeProxyURI # :nodoc:
+    def method_missing(meth, *args)
+      if %w(scheme host port path query userinfo).member?(meth.to_s)
+        return nil
+      end
       super
+    end
+  end
+
+  # :startdoc:
+
+  ##
+  # An HTTP Proxy server which proxies GET, HEAD and POST requests.
+  #
+  # To create a simple proxy server:
+  #
+  #   require 'webrick'
+  #   require 'webrick/httpproxy'
+  #
+  #   proxy = WEBrick::HTTPProxyServer.new Port: 8000
+  #
+  #   trap 'INT'  do proxy.shutdown end
+  #   trap 'TERM' do proxy.shutdown end
+  #
+  #   proxy.start
+  #
+  # See ::new for proxy-specific configuration items.
+  #
+  # == Modifying proxied responses
+  #
+  # To modify content the proxy server returns use the +:ProxyContentHandler+
+  # option:
+  #
+  #   handler = proc do |req, res|
+  #     if res['content-type'] == 'text/plain' then
+  #       res.body << "\nThis content was proxied!\n"
+  #     end
+  #   end
+  #
+  #   proxy =
+  #     WEBrick::HTTPProxyServer.new Port: 8000, ProxyContentHandler: handler
+
+  class HTTPProxyServer < HTTPServer
+
+    ##
+    # Proxy server configurations.  The proxy server handles the following
+    # configuration items in addition to those supported by HTTPServer:
+    #
+    # :ProxyAuthProc:: Called with a request and response to authorize a
+    #                  request
+    # :ProxyVia:: Appended to the via header
+    # :ProxyURI:: The proxy server's URI
+    # :ProxyContentHandler:: Called with a request and response and allows
+    #                        modification of the response
+    # :ProxyTimeout:: Sets the proxy timeouts to 30 seconds for open and 60
+    #                 seconds for read operations
+
+    def initialize(config={}, default=Config::HTTP)
+      super(config, default)
       c = @config
       @via = "#{c[:HTTPVersion]} #{c[:ServerName]}:#{c[:Port]}"
     end
 
+    # :stopdoc:
     def service(req, res)
       if req.request_method == "CONNECT"
-        proxy_connect(req, res)
+        do_CONNECT(req, res)
       elsif req.unparsed_uri =~ %r!^http://!
         proxy_service(req, res)
       else
@@ -47,118 +106,24 @@ module WEBrick
       req.header.delete("proxy-authorization")
     end
 
-    # Some header fields should not be transferred.
-    HopByHop = %w( connection keep-alive proxy-authenticate upgrade
-                   proxy-authorization te trailers transfer-encoding )
-    ShouldNotTransfer = %w( set-cookie proxy-connection )
-    def split_field(f) f ? f.split(/,\s+/).collect{|i| i.downcase } : [] end
-
-    def choose_header(src, dst)
-      connections = split_field(src['connection'])
-      src.each{|key, value|
-        key = key.downcase
-        if HopByHop.member?(key)          || # RFC2616: 13.5.1
-           connections.member?(key)       || # RFC2616: 14.10
-           ShouldNotTransfer.member?(key)    # pragmatics
-          @logger.debug("choose_header: `#{key}: #{value}'")
-          next
-        end
-        dst[key] = value
-      }
-    end
-
-    # Net::HTTP is stupid about the multiple header fields.
-    # Here is workaround:
-    def set_cookie(src, dst)
-      if str = src['set-cookie']
-        cookies = []
-        str.split(/,\s*/).each{|token|
-          if /^[^=]+;/o =~ token
-            cookies[-1] << ", " << token
-          elsif /=/o =~ token
-            cookies << token
-          else
-            cookies[-1] << ", " << token
-          end
-        }
-        dst.cookies.replace(cookies)
-      end
-    end
-
-    def set_via(h)
-      if @config[:ProxyVia]
-        if  h['via']
-          h['via'] << ", " << @via
-        else
-          h['via'] = @via
-        end
-      end
-    end
-
     def proxy_uri(req, res)
-      @config[:ProxyURI]
+      # should return upstream proxy server's URI
+      return @config[:ProxyURI]
     end
 
     def proxy_service(req, res)
       # Proxy Authentication
-      proxy_auth(req, res)      
-
-      # Create Request-URI to send to the origin server
-      uri  = req.request_uri
-      path = uri.path.dup
-      path << "?" << uri.query if uri.query
-
-      # Choose header fields to transfer
-      header = Hash.new
-      choose_header(req, header)
-      set_via(header)
-
-      # select upstream proxy server
-      if proxy = proxy_uri(req, res)
-        proxy_host = proxy.host
-        proxy_port = proxy.port
-        if proxy.userinfo
-          credentials = "Basic " + [proxy.userinfo].pack("m*")
-          credentials.chomp!
-          header['proxy-authorization'] = credentials
-        end
-      end
+      proxy_auth(req, res)
 
-      response = nil
       begin
-        http = Net::HTTP.new(uri.host, uri.port, proxy_host, proxy_port)
-        http.start{
-          if @config[:ProxyTimeout]
-            ##################################   these issues are 
-            http.open_timeout = 30   # secs  #   necessary (maybe bacause
-            http.read_timeout = 60   # secs  #   Ruby's bug, but why?)
-            ##################################
-          end
-          case req.request_method
-          when "GET"  then response = http.get(path, header)
-          when "POST" then response = http.post(path, req.body || "", header)
-          when "HEAD" then response = http.head(path, header)
-          else
-            raise HTTPStatus::MethodNotAllowed,
-              "unsupported method `#{req.request_method}'."
-          end
-        }
+        self.send("do_#{req.request_method}", req, res)
+      rescue NoMethodError
+        raise HTTPStatus::MethodNotAllowed,
+          "unsupported method `#{req.request_method}'."
       rescue => err
         logger.debug("#{err.class}: #{err.message}")
         raise HTTPStatus::ServiceUnavailable, err.message
       end
-  
-      # Persistent connction requirements are mysterious for me.
-      # So I will close the connection in every response.
-      res['proxy-connection'] = "close"
-      res['connection'] = "close"
-
-      # Convert Net::HTTP::HTTPResponse to WEBrick::HTTPProxy
-      res.status = response.code.to_i
-      choose_header(response, res)
-      set_cookie(response, res)
-      set_via(res)
-      res.body = response.body
 
       # Process contents
       if handler = @config[:ProxyContentHandler]
@@ -166,7 +131,7 @@ module WEBrick
       end
     end
 
-    def proxy_connect(req, res)
+    def do_CONNECT(req, res)
       # Proxy Authentication
       proxy_auth(req, res)
 
@@ -179,8 +144,7 @@ module WEBrick
       if proxy = proxy_uri(req, res)
         proxy_request_line = "CONNECT #{host}:#{port} HTTP/1.0"
         if proxy.userinfo
-          credentials = "Basic " + [proxy.userinfo].pack("m*")
-          credentials.chomp!
+          credentials = "Basic " + [proxy.userinfo].pack("m").delete("\n")
         end
         host, port = proxy.host, proxy.port
       end
@@ -222,7 +186,7 @@ module WEBrick
         res.send_response(ua)
         access_log(@config, req, res)
 
-        # Should clear request-line not to send the sesponse twice.
+        # Should clear request-line not to send the response twice.
         # see: HTTPServer#run
         req.parse(NullReader) rescue nil
       end
@@ -231,11 +195,11 @@ module WEBrick
         while fds = IO::select([ua, os])
           if fds[0].member?(ua)
             buf = ua.sysread(1024);
-            @logger.debug("CONNECT: #{buf.size} byte from User-Agent")
+            @logger.debug("CONNECT: #{buf.bytesize} byte from User-Agent")
             os.syswrite(buf)
           elsif fds[0].member?(os)
             buf = os.sysread(1024);
-            @logger.debug("CONNECT: #{buf.size} byte from #{host}:#{port}")
+            @logger.debug("CONNECT: #{buf.bytesize} byte from #{host}:#{port}")
             ua.syswrite(buf)
           end
         end
@@ -247,8 +211,129 @@ module WEBrick
       raise HTTPStatus::EOFError
     end
 
+    def do_GET(req, res)
+      perform_proxy_request(req, res) do |http, path, header|
+        http.get(path, header)
+      end
+    end
+
+    def do_HEAD(req, res)
+      perform_proxy_request(req, res) do |http, path, header|
+        http.head(path, header)
+      end
+    end
+
+    def do_POST(req, res)
+      perform_proxy_request(req, res) do |http, path, header|
+        http.post(path, req.body || "", header)
+      end
+    end
+
     def do_OPTIONS(req, res)
       res['allow'] = "GET,HEAD,POST,OPTIONS,CONNECT"
     end
+
+    private
+
+    # Some header fields should not be transferred.
+    HopByHop = %w( connection keep-alive proxy-authenticate upgrade
+                   proxy-authorization te trailers transfer-encoding )
+    ShouldNotTransfer = %w( set-cookie proxy-connection )
+    def split_field(f) f ? f.split(/,\s+/).collect{|i| i.downcase } : [] end
+
+    def choose_header(src, dst)
+      connections = split_field(src['connection'])
+      src.each{|key, value|
+        key = key.downcase
+        if HopByHop.member?(key)          || # RFC2616: 13.5.1
+           connections.member?(key)       || # RFC2616: 14.10
+           ShouldNotTransfer.member?(key)    # pragmatics
+          @logger.debug("choose_header: `#{key}: #{value}'")
+          next
+        end
+        dst[key] = value
+      }
+    end
+
+    # Net::HTTP is stupid about the multiple header fields.
+    # Here is workaround:
+    def set_cookie(src, dst)
+      if str = src['set-cookie']
+        cookies = []
+        str.split(/,\s*/).each{|token|
+          if /^[^=]+;/o =~ token
+            cookies[-1] << ", " << token
+          elsif /=/o =~ token
+            cookies << token
+          else
+            cookies[-1] << ", " << token
+          end
+        }
+        dst.cookies.replace(cookies)
+      end
+    end
+
+    def set_via(h)
+      if @config[:ProxyVia]
+        if  h['via']
+          h['via'] << ", " << @via
+        else
+          h['via'] = @via
+        end
+      end
+    end
+
+    def setup_proxy_header(req, res)
+      # Choose header fields to transfer
+      header = Hash.new
+      choose_header(req, header)
+      set_via(header)
+      return header
+    end
+
+    def setup_upstream_proxy_authentication(req, res, header)
+      if upstream = proxy_uri(req, res)
+        if upstream.userinfo
+          header['proxy-authorization'] =
+            "Basic " + [upstream.userinfo].pack("m").delete("\n")
+        end
+        return upstream
+      end
+      return FakeProxyURI
+    end
+
+    def perform_proxy_request(req, res)
+      uri = req.request_uri
+      path = uri.path.dup
+      path << "?" << uri.query if uri.query
+      header = setup_proxy_header(req, res)
+      upstream = setup_upstream_proxy_authentication(req, res, header)
+      response = nil
+
+      http = Net::HTTP.new(uri.host, uri.port, upstream.host, upstream.port)
+      http.start do
+        if @config[:ProxyTimeout]
+          ##################################   these issues are
+          http.open_timeout = 30   # secs  #   necessary (maybe bacause
+          http.read_timeout = 60   # secs  #   Ruby's bug, but why?)
+          ##################################
+        end
+        response = yield(http, path, header)
+      end
+
+      # Persistent connection requirements are mysterious for me.
+      # So I will close the connection in every response.
+      res['proxy-connection'] = "close"
+      res['connection'] = "close"
+
+      # Convert Net::HTTP::HTTPResponse to WEBrick::HTTPResponse
+      res.status = response.code.to_i
+      choose_header(response, res)
+      set_cookie(response, res)
+      set_via(res)
+      res.body = response.body
+    end
+
+    # :stopdoc:
   end
 end

data/lib/webrick/httprequest.rb

@@ -8,9 +8,7 @@
 #
 # $IPR: httprequest.rb,v 1.64 2003/07/13 17:18:22 gotoyuzo Exp $
 
-require 'timeout'
 require 'uri'
-
 require 'webrick/httpversion'
 require 'webrick/httpstatus'
 require 'webrick/httputils'
@@ -18,32 +16,141 @@ require 'webrick/cookie'
 
 module WEBrick
 
+  ##
+  # An HTTP request.  This is consumed by service and do_* methods in
+  # WEBrick servlets
+
   class HTTPRequest
-    BODY_CONTAINABLE_METHODS = [ "POST", "PUT" ]
-    BUFSIZE = 1024*4
 
-    # Request line
+    BODY_CONTAINABLE_METHODS = [ "POST", "PUT" ] # :nodoc:
+
+    # :section: Request line
+
+    ##
+    # The complete request line such as:
+    #
+    #   GET / HTTP/1.1
+
     attr_reader :request_line
-    attr_reader :request_method, :unparsed_uri, :http_version
 
-    # Request-URI
-    attr_reader :request_uri, :host, :port, :path
-    attr_accessor :script_name, :path_info, :query_string
+    ##
+    # The request method, GET, POST, PUT, etc.
+
+    attr_reader :request_method
+
+    ##
+    # The unparsed URI of the request
+
+    attr_reader :unparsed_uri
+
+    ##
+    # The HTTP version of the request
+
+    attr_reader :http_version
+
+    # :section: Request-URI
+
+    ##
+    # The parsed URI of the request
+
+    attr_reader :request_uri
+
+    ##
+    # The request path
+
+    attr_reader :path
+
+    ##
+    # The script name (CGI variable)
+
+    attr_accessor :script_name
+
+    ##
+    # The path info (CGI variable)
+
+    attr_accessor :path_info
+
+    ##
+    # The query from the URI of the request
+
+    attr_accessor :query_string
+
+    # :section: Header and entity body
+
+    ##
+    # The raw header of the request
+
+    attr_reader :raw_header
 
-    # Header and entity body
-    attr_reader :raw_header, :header, :cookies
-    attr_reader :accept, :accept_charset
-    attr_reader :accept_encoding, :accept_language
+    ##
+    # The parsed header of the request
+
+    attr_reader :header
+
+    ##
+    # The parsed request cookies
+
+    attr_reader :cookies
+
+    ##
+    # The Accept header value
+
+    attr_reader :accept
+
+    ##
+    # The Accept-Charset header value
+
+    attr_reader :accept_charset
+
+    ##
+    # The Accept-Encoding header value
+
+    attr_reader :accept_encoding
+
+    ##
+    # The Accept-Language header value
+
+    attr_reader :accept_language
+
+    # :section:
+
+    ##
+    # The remote user (CGI variable)
 
-    # Misc
     attr_accessor :user
-    attr_reader :addr, :peeraddr
+
+    ##
+    # The socket address of the server
+
+    attr_reader :addr
+
+    ##
+    # The socket address of the client
+
+    attr_reader :peeraddr
+
+    ##
+    # Hash of request attributes
+
     attr_reader :attributes
+
+    ##
+    # Is this a keep-alive connection?
+
     attr_reader :keep_alive
+
+    ##
+    # The local time this request was received
+
     attr_reader :request_time
 
+    ##
+    # Creates a new HTTP request.  WEBrick::Config::HTTP is the default
+    # configuration.
+
     def initialize(config)
       @config = config
+      @buffer_size = @config[:InputBufferSize]
       @logger = config[:Logger]
 
       @request_line = @request_method =
@@ -72,8 +179,15 @@ module WEBrick
 
       @remaining_size = nil
       @socket = nil
+
+      @forwarded_proto = @forwarded_host = @forwarded_port =
+        @forwarded_server = @forwarded_for = nil
     end
 
+    ##
+    # Parses a request from +socket+.  This is called internally by
+    # WEBrick::HTTPServer.
+
     def parse(socket=nil)
       @socket = socket
       begin
@@ -98,6 +212,7 @@ module WEBrick
       return if @unparsed_uri == "*"
 
       begin
+        setup_forwarded_info
         @request_uri = parse_uri(@unparsed_uri)
         @path = HTTPUtils::unescape(@request_uri.path)
         @path = HTTPUtils::normalize_path(@path)
@@ -121,12 +236,29 @@ module WEBrick
       end
     end
 
-    def body(&block)
+    ##
+    # Generate HTTP/1.1 100 continue response if the client expects it,
+    # otherwise does nothing.
+
+    def continue # :nodoc:
+      if self['expect'] == '100-continue' && @config[:HTTPVersion] >= "1.1"
+        @socket << "HTTP/#{@config[:HTTPVersion]} 100 continue#{CRLF}#{CRLF}"
+        @header.delete('expect')
+      end
+    end
+
+    ##
+    # Returns the request body.
+
+    def body(&block) # :yields: body_chunk
       block ||= Proc.new{|chunk| @body << chunk }
       read_body(@socket, block)
       @body.empty? ? nil : @body
     end
 
+    ##
+    # Request query as a Hash
+
     def query
       unless @query
         parse_query()
@@ -134,14 +266,23 @@ module WEBrick
       @query
     end
 
+    ##
+    # The content-length header
+
     def content_length
       return Integer(self['content-length'])
     end
 
+    ##
+    # The content-type header
+
     def content_type
       return self['content-type']
     end
 
+    ##
+    # Retrieves +header_name+
+
     def [](header_name)
       if @header
         value = @header[header_name.downcase]
@@ -149,18 +290,61 @@ module WEBrick
       end
     end
 
+    ##
+    # Iterates over the request headers
+
     def each
-      @header.each{|k, v|
-        value = @header[k]
-        yield(k, value.empty? ? nil : value.join(", "))
-      }
+      if @header
+        @header.each{|k, v|
+          value = @header[k]
+          yield(k, value.empty? ? nil : value.join(", "))
+        }
+      end
+    end
+
+    ##
+    # The host this request is for
+
+    def host
+      return @forwarded_host || @host
+    end
+
+    ##
+    # The port this request is for
+
+    def port
+      return @forwarded_port || @port
+    end
+
+    ##
+    # The server name this request is for
+
+    def server_name
+      return @forwarded_server || @config[:ServerName]
+    end
+
+    ##
+    # The client's IP address
+
+    def remote_ip
+      return self["client-ip"] || @forwarded_for || @peeraddr[3]
+    end
+
+    ##
+    # Is this an SSL request?
+
+    def ssl?
+      return @request_uri.scheme == "https"
     end
 
+    ##
+    # Should the connection this request was made on be kept alive?
+
     def keep_alive?
       @keep_alive
     end
 
-    def to_s
+    def to_s # :nodoc:
       ret = @request_line.dup
       @raw_header.each{|line| ret << line }
       ret << CRLF
@@ -168,7 +352,10 @@ module WEBrick
       ret
     end
 
-    def fixup()
+    ##
+    # Consumes any remaining body and updates keep-alive status
+
+    def fixup() # :nodoc:
       begin
         body{|chunk| }   # read remaining body
       rescue HTTPStatus::Error => ex
@@ -180,11 +367,11 @@ module WEBrick
       end
     end
 
-    def meta_vars
-      # This method provides the metavariables defined by the revision 3
-      # of ``The WWW Common Gateway Interface Version 1.1''.
-      # (http://Web.Golux.Com/coar/cgi/)
+    # This method provides the metavariables defined by the revision 3
+    # of "The WWW Common Gateway Interface Version 1.1"
+    # http://Web.Golux.Com/coar/cgi/
 
+    def meta_vars
       meta = Hash.new
 
       cl = self["Content-Length"]
@@ -221,11 +408,18 @@ module WEBrick
 
     private
 
+    # :stopdoc:
+
+    MAX_URI_LENGTH = 2083 # :nodoc:
+
     def read_request_line(socket)
-      @request_line = read_line(socket) if socket
+      @request_line = read_line(socket, MAX_URI_LENGTH) if socket
+      if @request_line.bytesize >= MAX_URI_LENGTH and @request_line[-1, 1] != LF
+        raise HTTPStatus::RequestURITooLarge
+      end
       @request_time = Time.now
       raise HTTPStatus::EOFError unless @request_line
-      if /^(\S+)\s+(\S+?)(?:\s+HTTP\/(\d+\.\d+))?\r?\n/mo =~ @request_line
+      if /^(\S+)\s+(\S++)(?:\s+HTTP\/(\d+\.\d+))?\r?\n/mo =~ @request_line
         @request_method = $1
         @unparsed_uri   = $2
         @http_version   = HTTPVersion.new($3 ? $3 : "0.9")
@@ -242,20 +436,19 @@ module WEBrick
           @raw_header << line
         end
       end
-      begin
-        @header = HTTPUtils::parse_header(@raw_header)
-      rescue => ex
-        raise  HTTPStatus::BadRequest, ex.message
-      end
+      @header = HTTPUtils::parse_header(@raw_header.join)
     end
 
     def parse_uri(str, scheme="http")
       if @config[:Escape8bitURI]
         str = HTTPUtils::escape8bit(str)
       end
+      str.sub!(%r{\A/+}o, '/')
       uri = URI::parse(str)
       return uri if uri.absolute?
-      if self["host"]
+      if @forwarded_host
+        host, port = @forwarded_host, @forwarded_port
+      elsif self["host"]
         pattern = /\A(#{URI::REGEXP::PATTERN::HOST})(?::(\d+))?\z/n
         host, port = *self['host'].scan(pattern)[0]
       elsif @addr.size > 0
@@ -263,7 +456,7 @@ module WEBrick
       else
         host, port = @config[:ServerName], @config[:Port]
       end
-      uri.scheme = scheme
+      uri.scheme = @forwarded_proto || scheme
       uri.host = host
       uri.port = port ? port.to_i : nil
       return URI::parse(uri.to_s)
@@ -278,10 +471,10 @@ module WEBrick
         end
       elsif self['content-length'] || @remaining_size
         @remaining_size ||= self['content-length'].to_i
-        while @remaining_size > 0 
-          sz = BUFSIZE < @remaining_size ? BUFSIZE : @remaining_size
+        while @remaining_size > 0
+          sz = [@buffer_size, @remaining_size].min
           break unless buf = read_data(socket, sz)
-          @remaining_size -= buf.size
+          @remaining_size -= buf.bytesize
           block.call(buf)
         end
         if @remaining_size > 0 && @socket.eof?
@@ -307,13 +500,8 @@ module WEBrick
     def read_chunked(socket, block)
       chunk_size, = read_chunk_size(socket)
       while chunk_size > 0
-        data = ""
-        while data.size < chunk_size
-          tmp = read_data(socket, chunk_size-data.size) # read chunk-data
-          break unless tmp
-          data << tmp
-        end
-        if data.nil? || data.size != chunk_size
+        data = read_data(socket, chunk_size) # read chunk-data
+        if data.nil? || data.bytesize != chunk_size
           raise BadRequest, "bad chunk data size."
         end
         read_line(socket)                    # skip CRLF
@@ -325,10 +513,10 @@ module WEBrick
       @remaining_size = 0
     end
 
-    def _read_data(io, method, arg)
+    def _read_data(io, method, *arg)
       begin
-        timeout(@config[:RequestTimeout]){
-          return io.__send__(method, arg)
+        WEBrick::Utils.timeout(@config[:RequestTimeout]){
+          return io.__send__(method, *arg)
         }
       rescue Errno::ECONNRESET
         return nil
@@ -337,8 +525,8 @@ module WEBrick
       end
     end
 
-    def read_line(io)
-      _read_data(io, :gets, LF)
+    def read_line(io, size=4096)
+      _read_data(io, :gets, LF, size)
     end
 
     def read_data(io, size)
@@ -361,5 +549,35 @@ module WEBrick
         raise HTTPStatus::BadRequest, ex.message
       end
     end
+
+    PrivateNetworkRegexp = /
+      ^unknown$|
+      ^((::ffff:)?127.0.0.1|::1)$|
+      ^(::ffff:)?(10|172\.(1[6-9]|2[0-9]|3[01])|192\.168)\.
+    /ixo
+
+    # It's said that all X-Forwarded-* headers will contain more than one
+    # (comma-separated) value if the original request already contained one of
+    # these headers. Since we could use these values as Host header, we choose
+    # the initial(first) value. (apr_table_mergen() adds new value after the
+    # existing value with ", " prefix)
+    def setup_forwarded_info
+      if @forwarded_server = self["x-forwarded-server"]
+        @forwarded_server = @forwarded_server.split(",", 2).first
+      end
+      @forwarded_proto = self["x-forwarded-proto"]
+      if host_port = self["x-forwarded-host"]
+        host_port = host_port.split(",", 2).first
+        @forwarded_host, tmp = host_port.split(":", 2)
+        @forwarded_port = (tmp || (@forwarded_proto == "https" ? 443 : 80)).to_i
+      end
+      if addrs = self["x-forwarded-for"]
+        addrs = addrs.split(",").collect(&:strip)
+        addrs.reject!{|ip| PrivateNetworkRegexp =~ ip }
+        @forwarded_for = addrs.first
+      end
+    end
+
+    # :startdoc:
   end
 end