webrick 1.3.1 → 1.5.0

data/lib/webrick/httpresponse.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: false
 #
 # httpresponse.rb -- HTTPResponse Class
 #
@@ -9,32 +10,91 @@
 # $IPR: httpresponse.rb,v 1.45 2003/07/11 11:02:25 gotoyuzo Exp $
 
 require 'time'
-require 'webrick/httpversion'
-require 'webrick/htmlutils'
-require 'webrick/httputils'
-require 'webrick/httpstatus'
+require 'uri'
+require_relative 'httpversion'
+require_relative 'htmlutils'
+require_relative 'httputils'
+require_relative 'httpstatus'
 
 module WEBrick
   ##
-  # An HTTP response.
+  # An HTTP response.  This is filled in by the service or do_* methods of a
+  # WEBrick HTTP Servlet.
 
   class HTTPResponse
-    attr_reader :http_version, :status, :header
+    class InvalidHeader < StandardError
+    end
+
+    ##
+    # HTTP Response version
+
+    attr_reader :http_version
+
+    ##
+    # Response status code (200)
+
+    attr_reader :status
+
+    ##
+    # Response header
+
+    attr_reader :header
+
+    ##
+    # Response cookies
+
     attr_reader :cookies
+
+    ##
+    # Response reason phrase ("OK")
+
     attr_accessor :reason_phrase
 
     ##
-    # Body may be a String or IO subclass.
+    # Body may be a String or IO-like object that responds to #read and
+    # #readpartial.
 
     attr_accessor :body
 
-    attr_accessor :request_method, :request_uri, :request_http_version
+    ##
+    # Request method for this response
+
+    attr_accessor :request_method
+
+    ##
+    # Request URI for this response
+
+    attr_accessor :request_uri
+
+    ##
+    # Request HTTP version for this response
+
+    attr_accessor :request_http_version
+
+    ##
+    # Filename of the static file in this response.  Only used by the
+    # FileHandler servlet.
+
     attr_accessor :filename
+
+    ##
+    # Is this a keep-alive response?
+
     attr_accessor :keep_alive
-    attr_reader :config, :sent_size
 
     ##
-    # Creates a new HTTP response object
+    # Configuration for this response
+
+    attr_reader :config
+
+    ##
+    # Bytes sent in this response
+
+    attr_reader :sent_size
+
+    ##
+    # Creates a new HTTP response object.  WEBrick::Config::HTTP is the
+    # default configuration.
 
     def initialize(config)
       @config = config
@@ -53,13 +113,14 @@ module WEBrick
       @chunked = false
       @filename = nil
       @sent_size = 0
+      @bodytempfile = nil
     end
 
     ##
     # The response's HTTP status line
 
     def status_line
-      "HTTP/#@http_version #@status #@reason_phrase #{CRLF}"
+      "HTTP/#@http_version #@status #@reason_phrase".rstrip << CRLF
     end
 
     ##
@@ -115,7 +176,7 @@ module WEBrick
     end
 
     ##
-    # Iterates over each header in the resopnse
+    # Iterates over each header in the response
 
     def each
       @header.each{|field, value|  yield(field, value) }
@@ -145,7 +206,7 @@ module WEBrick
     ##
     # Sends the response on +socket+
 
-    def send_response(socket)
+    def send_response(socket) # :nodoc:
       begin
         setup_header()
         send_header(socket)
@@ -162,7 +223,7 @@ module WEBrick
     ##
     # Sets up the headers for sending
 
-    def setup_header()
+    def setup_header() # :nodoc:
       @reason_phrase    ||= HTTPStatus::reason_phrase(@status)
       @header['server'] ||= @config[:ServerSoftware]
       @header['date']   ||= Time.now.httpdate
@@ -193,8 +254,11 @@ module WEBrick
       elsif %r{^multipart/byteranges} =~ @header['content-type']
         @header.delete('content-length')
       elsif @header['content-length'].nil?
-        unless @body.is_a?(IO)
-          @header['content-length'] = @body ? @body.bytesize : 0
+        if @body.respond_to? :readpartial
+        elsif @body.respond_to? :call
+          make_body_tempfile
+        else
+          @header['content-length'] = (@body ? @body.bytesize : 0).to_s
         end
       end
 
@@ -217,45 +281,74 @@ module WEBrick
       # Location is a single absoluteURI.
       if location = @header['location']
         if @request_uri
-          @header['location'] = @request_uri.merge(location)
+          @header['location'] = @request_uri.merge(location).to_s
         end
       end
     end
 
+    def make_body_tempfile # :nodoc:
+      return if @bodytempfile
+      bodytempfile = Tempfile.create("webrick")
+      if @body.nil?
+        # nothing
+      elsif @body.respond_to? :readpartial
+        IO.copy_stream(@body, bodytempfile)
+        @body.close
+      elsif @body.respond_to? :call
+        @body.call(bodytempfile)
+      else
+        bodytempfile.write @body
+      end
+      bodytempfile.rewind
+      @body = @bodytempfile = bodytempfile
+      @header['content-length'] = bodytempfile.stat.size.to_s
+    end
+
+    def remove_body_tempfile # :nodoc:
+      if @bodytempfile
+        @bodytempfile.close
+        File.unlink @bodytempfile.path
+        @bodytempfile = nil
+      end
+    end
+
+
     ##
     # Sends the headers on +socket+
 
-    def send_header(socket)
+    def send_header(socket) # :nodoc:
       if @http_version.major > 0
         data = status_line()
         @header.each{|key, value|
           tmp = key.gsub(/\bwww|^te$|\b\w/){ $&.upcase }
-          data << "#{tmp}: #{value}" << CRLF
+          data << "#{tmp}: #{check_header(value)}" << CRLF
         }
         @cookies.each{|cookie|
-          data << "Set-Cookie: " << cookie.to_s << CRLF
+          data << "Set-Cookie: " << check_header(cookie.to_s) << CRLF
         }
         data << CRLF
-        _write_data(socket, data)
+        socket.write(data)
       end
+    rescue InvalidHeader => e
+      @header.clear
+      @cookies.clear
+      set_error e
+      retry
     end
 
     ##
     # Sends the body on +socket+
 
-    def send_body(socket)
-      case @body
-      when IO then send_body_io(socket)
-      else send_body_string(socket)
+    def send_body(socket) # :nodoc:
+      if @body.respond_to? :readpartial then
+        send_body_io(socket)
+      elsif @body.respond_to?(:call) then
+        send_body_proc(socket)
+      else
+        send_body_string(socket)
       end
     end
 
-    def to_s # :nodoc:
-      ret = ""
-      send_response(ret)
-      ret
-    end
-
     ##
     # Redirects to +url+ with a WEBrick::HTTPStatus::Redirect +status+.
     #
@@ -264,8 +357,9 @@ module WEBrick
     #   res.set_redirect WEBrick::HTTPStatus::TemporaryRedirect
 
     def set_redirect(status, url)
-      @body = "<HTML><A HREF=\"#{url.to_s}\">#{url.to_s}</A>.</HTML>\n"
-      @header['location'] = url.to_s
+      url = URI(url).to_s
+      @body = "<HTML><A HREF=\"#{url}\">#{url}</A>.</HTML>\n"
+      @header['location'] = url
       raise status
     end
 
@@ -294,6 +388,23 @@ module WEBrick
         host, port = @config[:ServerName], @config[:Port]
       end
 
+      error_body(backtrace, ex, host, port)
+    end
+
+    private
+
+    def check_header(header_value)
+      header_value = header_value.to_s
+      if /[\r\n]/ =~ header_value
+        raise InvalidHeader
+      else
+        header_value
+      end
+    end
+
+    # :stopdoc:
+
+    def error_body(backtrace, ex, host, port)
       @body = ''
       @body << <<-_end_of_html_
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
@@ -323,30 +434,44 @@ module WEBrick
       _end_of_html_
     end
 
-    private
-
     def send_body_io(socket)
       begin
         if @request_method == "HEAD"
           # do nothing
         elsif chunked?
-          while buf = @body.read(@buffer_size)
-            next if buf.empty?
-            data = ""
-            data << format("%x", buf.bytesize) << CRLF
-            data << buf << CRLF
-            _write_data(socket, data)
-            @sent_size += buf.bytesize
-          end
-          _write_data(socket, "0#{CRLF}#{CRLF}")
+          buf  = ''
+          begin
+            @body.readpartial(@buffer_size, buf)
+            size = buf.bytesize
+            data = "#{size.to_s(16)}#{CRLF}#{buf}#{CRLF}"
+            socket.write(data)
+            data.clear
+            @sent_size += size
+          rescue EOFError
+            break
+          end while true
+          buf.clear
+          socket.write("0#{CRLF}#{CRLF}")
         else
-          size = @header['content-length'].to_i
-          _send_file(socket, @body, 0, size)
-          @sent_size = size
+          if %r{\Abytes (\d+)-(\d+)/\d+\z} =~ @header['content-range']
+            offset = $1.to_i
+            size = $2.to_i - offset + 1
+          else
+            offset = nil
+            size = @header['content-length']
+            size = size.to_i if size
+          end
+          begin
+            @sent_size = IO.copy_stream(@body, socket, size, offset)
+          rescue NotImplementedError
+            @body.seek(offset, IO::SEEK_SET)
+            @sent_size = IO.copy_stream(@body, socket, size)
+          end
         end
       ensure
         @body.close
       end
+      remove_body_tempfile
     end
 
     def send_body_string(socket)
@@ -356,44 +481,70 @@ module WEBrick
         body ? @body.bytesize : 0
         while buf = @body[@sent_size, @buffer_size]
           break if buf.empty?
-          data = ""
-          data << format("%x", buf.bytesize) << CRLF
-          data << buf << CRLF
-          _write_data(socket, data)
-          @sent_size += buf.bytesize
+          size = buf.bytesize
+          data = "#{size.to_s(16)}#{CRLF}#{buf}#{CRLF}"
+          buf.clear
+          socket.write(data)
+          @sent_size += size
         end
-        _write_data(socket, "0#{CRLF}#{CRLF}")
+        socket.write("0#{CRLF}#{CRLF}")
       else
         if @body && @body.bytesize > 0
-          _write_data(socket, @body)
+          socket.write(@body)
           @sent_size = @body.bytesize
         end
       end
     end
 
-    def _send_file(output, input, offset, size)
-      while offset > 0
-        sz = @buffer_size < size ? @buffer_size : size
-        buf = input.read(sz)
-        offset -= buf.bytesize
-      end
-
-      if size == 0
-        while buf = input.read(@buffer_size)
-          _write_data(output, buf)
-        end
+    def send_body_proc(socket)
+      if @request_method == "HEAD"
+        # do nothing
+      elsif chunked?
+        @body.call(ChunkedWrapper.new(socket, self))
+        socket.write("0#{CRLF}#{CRLF}")
       else
-        while size > 0
-          sz = @buffer_size < size ? @buffer_size : size
-          buf = input.read(sz)
-          _write_data(output, buf)
-          size -= buf.bytesize
+        size = @header['content-length'].to_i
+        if @bodytempfile
+          @bodytempfile.rewind
+          IO.copy_stream(@bodytempfile, socket)
+        else
+          @body.call(socket)
         end
+        @sent_size = size
       end
     end
 
+    class ChunkedWrapper
+      def initialize(socket, resp)
+        @socket = socket
+        @resp = resp
+      end
+
+      def write(buf)
+        return 0 if buf.empty?
+        socket = @socket
+        @resp.instance_eval {
+          size = buf.bytesize
+          data = "#{size.to_s(16)}#{CRLF}#{buf}#{CRLF}"
+          socket.write(data)
+          data.clear
+          @sent_size += size
+          size
+        }
+      end
+
+      def <<(*buf)
+        write(buf)
+        self
+      end
+    end
+
+    # preserved for compatibility with some 3rd-party handlers
     def _write_data(socket, data)
       socket << data
     end
+
+    # :startdoc:
   end
+
 end

data/lib/webrick/https.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: false
 #
 # https.rb -- SSL/TLS enhancement for HTTPServer
 #
@@ -8,15 +9,36 @@
 #
 # $IPR: https.rb,v 1.15 2003/07/22 19:20:42 gotoyuzo Exp $
 
-require 'webrick/ssl'
+require_relative 'ssl'
+require_relative 'httpserver'
 
 module WEBrick
   module Config
     HTTP.update(SSL)
   end
 
+  ##
+  #--
+  # Adds SSL functionality to WEBrick::HTTPRequest
+
   class HTTPRequest
-    attr_reader :cipher, :server_cert, :client_cert
+
+    ##
+    # HTTP request SSL cipher
+
+    attr_reader :cipher
+
+    ##
+    # HTTP request server certificate
+
+    attr_reader :server_cert
+
+    ##
+    # HTTP request client certificate
+
+    attr_reader :client_cert
+
+    # :stopdoc:
 
     alias orig_parse parse
 
@@ -60,5 +82,71 @@ module WEBrick
       end
       meta
     end
+
+    # :startdoc:
+  end
+
+  ##
+  #--
+  # Fake WEBrick::HTTPRequest for lookup_server
+
+  class SNIRequest
+
+    ##
+    # The SNI hostname
+
+    attr_reader :host
+
+    ##
+    # The socket address of the server
+
+    attr_reader :addr
+
+    ##
+    # The port this request is for
+
+    attr_reader :port
+
+    ##
+    # Creates a new SNIRequest.
+
+    def initialize(sslsocket, hostname)
+      @host = hostname
+      @addr = sslsocket.addr
+      @port = @addr[1]
+    end
+  end
+
+
+  ##
+  #--
+  # Adds SSL functionality to WEBrick::HTTPServer
+
+  class HTTPServer < ::WEBrick::GenericServer
+    ##
+    # ServerNameIndication callback
+
+    def ssl_servername_callback(sslsocket, hostname = nil)
+      req = SNIRequest.new(sslsocket, hostname)
+      server = lookup_server(req)
+      server ? server.ssl_context : nil
+    end
+
+    # :stopdoc:
+
+    ##
+    # Check whether +server+ is also SSL server.
+    # Also +server+'s SSL context will be created.
+
+    alias orig_virtual_host virtual_host
+
+    def virtual_host(server)
+      if @config[:SSLEnable] && !server.ssl_context
+        raise ArgumentError, "virtual host must set SSLEnable to true"
+      end
+      orig_virtual_host(server)
+    end
+
+    # :startdoc:
   end
 end

data/lib/webrick/httpserver.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: false
 #
 # httpserver.rb -- HTTPServer Class
 #
@@ -8,13 +9,14 @@
 #
 # $IPR: httpserver.rb,v 1.63 2002/10/01 17:16:32 gotoyuzo Exp $
 
-require 'webrick/server'
-require 'webrick/httputils'
-require 'webrick/httpstatus'
-require 'webrick/httprequest'
-require 'webrick/httpresponse'
-require 'webrick/httpservlet'
-require 'webrick/accesslog'
+require 'io/wait'
+require_relative 'server'
+require_relative 'httputils'
+require_relative 'httpstatus'
+require_relative 'httprequest'
+require_relative 'httpresponse'
+require_relative 'httpservlet'
+require_relative 'accesslog'
 
 module WEBrick
   class HTTPServerError < ServerError; end
@@ -66,17 +68,17 @@ module WEBrick
 
     def run(sock)
       while true
-        res = HTTPResponse.new(@config)
-        req = HTTPRequest.new(@config)
+        req = create_request(@config)
+        res = create_response(@config)
         server = self
         begin
           timeout = @config[:RequestTimeout]
           while timeout > 0
-            break if IO.select([sock], nil, nil, 0.5)
-            timeout = 0 if @status != :Running
+            break if sock.to_io.wait_readable(0.5)
+            break if @status != :Running
             timeout -= 0.5
           end
-          raise HTTPStatus::EOFError if timeout <= 0
+          raise HTTPStatus::EOFError if timeout <= 0 || @status != :Running
           raise HTTPStatus::EOFError if sock.eof?
           req.parse(sock)
           res.request_method = req.request_method
@@ -138,6 +140,10 @@ module WEBrick
       si.service(req, res)
     end
 
+    ##
+    # The default OPTIONS request handler says GET, HEAD, POST and OPTIONS
+    # requests are allowed.
+
     def do_OPTIONS(req, res)
       res["allow"] = "GET,HEAD,POST,OPTIONS"
     end
@@ -207,6 +213,10 @@ module WEBrick
       }
     end
 
+    ##
+    # Logs +req+ and +res+ in the access logs.  +config+ is used for the
+    # server name.
+
     def access_log(config, req, res)
       param = AccessLog::setup_params(config, req, res)
       @config[:AccessLog].each{|logger, fmt|
@@ -214,7 +224,27 @@ module WEBrick
       }
     end
 
-    class MountTable
+    ##
+    # Creates the HTTPRequest used when handling the HTTP
+    # request. Can be overridden by subclasses.
+    def create_request(with_webrick_config)
+      HTTPRequest.new(with_webrick_config)
+    end
+
+    ##
+    # Creates the HTTPResponse used when handling the HTTP
+    # request. Can be overridden by subclasses.
+    def create_response(with_webrick_config)
+      HTTPResponse.new(with_webrick_config)
+    end
+
+    ##
+    # Mount table for the path a servlet is mounted on in the directory space
+    # of the server.  Users of WEBrick can only access this indirectly via
+    # WEBrick::HTTPServer#mount, WEBrick::HTTPServer#unmount and
+    # WEBrick::HTTPServer#search_servlet
+
+    class MountTable # :nodoc:
       def initialize
         @tab = Hash.new
         compile
@@ -251,12 +281,12 @@ module WEBrick
         k.sort!
         k.reverse!
         k.collect!{|path| Regexp.escape(path) }
-        @scanner = Regexp.new("^(" + k.join("|") +")(?=/|$)")
+        @scanner = Regexp.new("\\A(" + k.join("|") +")(?=/|\\z)")
       end
 
       def normalize(dir)
         ret = dir ? dir.dup : ""
-        ret.sub!(%r|/+$|, "")
+        ret.sub!(%r|/+\z|, "")
         ret
       end
     end

data/lib/webrick/httpservlet/abstract.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: false
 #
 # httpservlet.rb -- HTTPServlet Module
 #
@@ -8,11 +9,9 @@
 #
 # $IPR: abstract.rb,v 1.24 2003/07/11 11:16:46 gotoyuzo Exp $
 
-require 'thread'
-
-require 'webrick/htmlutils'
-require 'webrick/httputils'
-require 'webrick/httpstatus'
+require_relative '../htmlutils'
+require_relative '../httputils'
+require_relative '../httpstatus'
 
 module WEBrick
   module HTTPServlet
@@ -54,7 +53,7 @@ module WEBrick
     # Servlets can be configured via initialize.  The first argument is the
     # HTTP server the servlet is being initialized for.
     #
-    #  class Configureable < Simple
+    #  class Configurable < Simple
     #    def initialize server, color, size
     #      super server
     #      @color = color