rubysl-webrick 1.0.0

data/lib/webrick/httprequest.rb

@@ -0,0 +1,365 @@
+#
+# httprequest.rb -- HTTPRequest Class
+#
+# Author: IPR -- Internet Programming with Ruby -- writers
+# Copyright (c) 2000, 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
+# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
+# reserved.
+#
+# $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'
+require 'webrick/cookie'
+
+module WEBrick
+
+  class HTTPRequest
+    BODY_CONTAINABLE_METHODS = [ "POST", "PUT" ]
+    BUFSIZE = 1024*4
+
+    # Request line
+    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
+
+    # Header and entity body
+    attr_reader :raw_header, :header, :cookies
+    attr_reader :accept, :accept_charset
+    attr_reader :accept_encoding, :accept_language
+
+    # Misc
+    attr_accessor :user
+    attr_reader :addr, :peeraddr
+    attr_reader :attributes
+    attr_reader :keep_alive
+    attr_reader :request_time
+
+    def initialize(config)
+      @config = config
+      @logger = config[:Logger]
+
+      @request_line = @request_method =
+        @unparsed_uri = @http_version = nil
+
+      @request_uri = @host = @port = @path = nil
+      @script_name = @path_info = nil
+      @query_string = nil
+      @query = nil
+      @form_data = nil
+
+      @raw_header = Array.new
+      @header = nil
+      @cookies = []
+      @accept = []
+      @accept_charset = []
+      @accept_encoding = []
+      @accept_language = []
+      @body = ""
+
+      @addr = @peeraddr = nil
+      @attributes = {}
+      @user = nil
+      @keep_alive = false
+      @request_time = nil
+
+      @remaining_size = nil
+      @socket = nil
+    end
+
+    def parse(socket=nil)
+      @socket = socket
+      begin
+        @peeraddr = socket.respond_to?(:peeraddr) ? socket.peeraddr : []
+        @addr = socket.respond_to?(:addr) ? socket.addr : []
+      rescue Errno::ENOTCONN
+        raise HTTPStatus::EOFError
+      end
+
+      read_request_line(socket)
+      if @http_version.major > 0
+        read_header(socket)
+        @header['cookie'].each{|cookie|
+          @cookies += Cookie::parse(cookie)
+        }
+        @accept = HTTPUtils.parse_qvalues(self['accept'])
+        @accept_charset = HTTPUtils.parse_qvalues(self['accept-charset'])
+        @accept_encoding = HTTPUtils.parse_qvalues(self['accept-encoding'])
+        @accept_language = HTTPUtils.parse_qvalues(self['accept-language'])
+      end
+      return if @request_method == "CONNECT"
+      return if @unparsed_uri == "*"
+
+      begin
+        @request_uri = parse_uri(@unparsed_uri)
+        @path = HTTPUtils::unescape(@request_uri.path)
+        @path = HTTPUtils::normalize_path(@path)
+        @host = @request_uri.host
+        @port = @request_uri.port
+        @query_string = @request_uri.query
+        @script_name = ""
+        @path_info = @path.dup
+      rescue
+        raise HTTPStatus::BadRequest, "bad URI `#{@unparsed_uri}'."
+      end
+
+      if /close/io =~ self["connection"]
+        @keep_alive = false
+      elsif /keep-alive/io =~ self["connection"]
+        @keep_alive = true
+      elsif @http_version < "1.1"
+        @keep_alive = false
+      else
+        @keep_alive = true
+      end
+    end
+
+    def body(&block)
+      block ||= Proc.new{|chunk| @body << chunk }
+      read_body(@socket, block)
+      @body.empty? ? nil : @body
+    end
+
+    def query
+      unless @query
+        parse_query()
+      end
+      @query
+    end
+
+    def content_length
+      return Integer(self['content-length'])
+    end
+
+    def content_type
+      return self['content-type']
+    end
+
+    def [](header_name)
+      if @header
+        value = @header[header_name.downcase]
+        value.empty? ? nil : value.join(", ")
+      end
+    end
+
+    def each
+      @header.each{|k, v|
+        value = @header[k]
+        yield(k, value.empty? ? nil : value.join(", "))
+      }
+    end
+
+    def keep_alive?
+      @keep_alive
+    end
+
+    def to_s
+      ret = @request_line.dup
+      @raw_header.each{|line| ret << line }
+      ret << CRLF
+      ret << body if body
+      ret
+    end
+
+    def fixup()
+      begin
+        body{|chunk| }   # read remaining body
+      rescue HTTPStatus::Error => ex
+        @logger.error("HTTPRequest#fixup: #{ex.class} occured.")
+        @keep_alive = false
+      rescue => ex
+        @logger.error(ex)
+        @keep_alive = false
+      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/)
+
+      meta = Hash.new
+
+      cl = self["Content-Length"]
+      ct = self["Content-Type"]
+      meta["CONTENT_LENGTH"]    = cl if cl.to_i > 0
+      meta["CONTENT_TYPE"]      = ct.dup if ct
+      meta["GATEWAY_INTERFACE"] = "CGI/1.1"
+      meta["PATH_INFO"]         = @path_info ? @path_info.dup : ""
+     #meta["PATH_TRANSLATED"]   = nil      # no plan to be provided
+      meta["QUERY_STRING"]      = @query_string ? @query_string.dup : ""
+      meta["REMOTE_ADDR"]       = @peeraddr[3]
+      meta["REMOTE_HOST"]       = @peeraddr[2]
+     #meta["REMOTE_IDENT"]      = nil      # no plan to be provided
+      meta["REMOTE_USER"]       = @user
+      meta["REQUEST_METHOD"]    = @request_method.dup
+      meta["REQUEST_URI"]       = @request_uri.to_s
+      meta["SCRIPT_NAME"]       = @script_name.dup
+      meta["SERVER_NAME"]       = @host
+      meta["SERVER_PORT"]       = @port.to_s
+      meta["SERVER_PROTOCOL"]   = "HTTP/" + @config[:HTTPVersion].to_s
+      meta["SERVER_SOFTWARE"]   = @config[:ServerSoftware].dup
+
+      self.each{|key, val|
+        next if /^content-type$/i =~ key
+        next if /^content-length$/i =~ key
+        name = "HTTP_" + key
+        name.gsub!(/-/o, "_")
+        name.upcase!
+        meta[name] = val
+      }
+
+      meta
+    end
+
+    private
+
+    def read_request_line(socket)
+      @request_line = read_line(socket) if socket
+      @request_time = Time.now
+      raise HTTPStatus::EOFError unless @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")
+      else
+        rl = @request_line.sub(/\x0d?\x0a\z/o, '')
+        raise HTTPStatus::BadRequest, "bad Request-Line `#{rl}'."
+      end
+    end
+
+    def read_header(socket)
+      if socket
+        while line = read_line(socket)
+          break if /\A(#{CRLF}|#{LF})\z/om =~ line
+          @raw_header << line
+        end
+      end
+      begin
+        @header = HTTPUtils::parse_header(@raw_header)
+      rescue => ex
+        raise  HTTPStatus::BadRequest, ex.message
+      end
+    end
+
+    def parse_uri(str, scheme="http")
+      if @config[:Escape8bitURI]
+        str = HTTPUtils::escape8bit(str)
+      end
+      uri = URI::parse(str)
+      return uri if uri.absolute?
+      if self["host"]
+        pattern = /\A(#{URI::REGEXP::PATTERN::HOST})(?::(\d+))?\z/n
+        host, port = *self['host'].scan(pattern)[0]
+      elsif @addr.size > 0
+        host, port = @addr[2], @addr[1]
+      else
+        host, port = @config[:ServerName], @config[:Port]
+      end
+      uri.scheme = scheme
+      uri.host = host
+      uri.port = port ? port.to_i : nil
+      return URI::parse(uri.to_s)
+    end
+
+    def read_body(socket, block)
+      return unless socket
+      if tc = self['transfer-encoding']
+        case tc
+        when /chunked/io then read_chunked(socket, block)
+        else raise HTTPStatus::NotImplemented, "Transfer-Encoding: #{tc}."
+        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
+          break unless buf = read_data(socket, sz)
+          @remaining_size -= buf.size
+          block.call(buf)
+        end
+        if @remaining_size > 0 && @socket.eof?
+          raise HTTPStatus::BadRequest, "invalid body size."
+        end
+      elsif BODY_CONTAINABLE_METHODS.member?(@request_method)
+        raise HTTPStatus::LengthRequired
+      end
+      return @body
+    end
+
+    def read_chunk_size(socket)
+      line = read_line(socket)
+      if /^([0-9a-fA-F]+)(?:;(\S+))?/ =~ line
+        chunk_size = $1.hex
+        chunk_ext = $2
+        [ chunk_size, chunk_ext ]
+      else
+        raise HTTPStatus::BadRequest, "bad chunk `#{line}'."
+      end
+    end
+
+    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
+          raise BadRequest, "bad chunk data size."
+        end
+        read_line(socket)                    # skip CRLF
+        block.call(data)
+        chunk_size, = read_chunk_size(socket)
+      end
+      read_header(socket)                    # trailer + CRLF
+      @header.delete("transfer-encoding")
+      @remaining_size = 0
+    end
+
+    def _read_data(io, method, arg)
+      begin
+        timeout(@config[:RequestTimeout]){
+          return io.__send__(method, arg)
+        }
+      rescue Errno::ECONNRESET
+        return nil
+      rescue TimeoutError
+        raise HTTPStatus::RequestTimeout
+      end
+    end
+
+    def read_line(io)
+      _read_data(io, :gets, LF)
+    end
+
+    def read_data(io, size)
+      _read_data(io, :read, size)
+    end
+
+    def parse_query()
+      begin
+        if @request_method == "GET" || @request_method == "HEAD"
+          @query = HTTPUtils::parse_query(@query_string)
+        elsif self['content-type'] =~ /^application\/x-www-form-urlencoded/
+          @query = HTTPUtils::parse_query(body)
+        elsif self['content-type'] =~ /^multipart\/form-data; boundary=(.+)/
+          boundary = HTTPUtils::dequote($1)
+          @query = HTTPUtils::parse_form_data(body, boundary)
+        else
+          @query = Hash.new
+        end
+      rescue => ex
+        raise HTTPStatus::BadRequest, ex.message
+      end
+    end
+  end
+end

data/lib/webrick/httpresponse.rb

@@ -0,0 +1,327 @@
+#
+# httpresponse.rb -- HTTPResponse Class
+#
+# Author: IPR -- Internet Programming with Ruby -- writers
+# Copyright (c) 2000, 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
+# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
+# reserved.
+#
+# $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'
+
+module WEBrick
+  class HTTPResponse
+    BUFSIZE = 1024*4
+
+    attr_reader :http_version, :status, :header
+    attr_reader :cookies
+    attr_accessor :reason_phrase
+    attr_accessor :body
+
+    attr_accessor :request_method, :request_uri, :request_http_version
+    attr_accessor :filename
+    attr_accessor :keep_alive
+    attr_reader :config, :sent_size
+
+    def initialize(config)
+      @config = config
+      @logger = config[:Logger]
+      @header = Hash.new
+      @status = HTTPStatus::RC_OK
+      @reason_phrase = nil
+      @http_version = HTTPVersion::convert(@config[:HTTPVersion])
+      @body = ''
+      @keep_alive = true
+      @cookies = []
+      @request_method = nil
+      @request_uri = nil
+      @request_http_version = @http_version  # temporary
+      @chunked = false
+      @filename = nil
+      @sent_size = 0
+    end
+
+    def status_line
+      "HTTP/#@http_version #@status #@reason_phrase #{CRLF}"
+    end
+
+    def status=(status)
+      @status = status
+      @reason_phrase = HTTPStatus::reason_phrase(status)
+    end
+
+    def [](field)
+      @header[field.downcase]
+    end
+
+    def []=(field, value)
+      @header[field.downcase] = value.to_s
+    end
+
+    def content_length
+      if len = self['content-length']
+        return Integer(len)
+      end
+    end
+
+    def content_length=(len)
+      self['content-length'] = len.to_s
+    end
+
+    def content_type
+      self['content-type']
+    end
+
+    def content_type=(type)
+      self['content-type'] = type
+    end
+
+    def each
+      @header.each{|k, v|  yield(k, v) }
+    end
+
+    def chunked?
+      @chunked
+    end
+
+    def chunked=(val)
+      @chunked = val ? true : false
+    end
+
+    def keep_alive?
+      @keep_alive
+    end
+
+    def send_response(socket)
+      begin
+        setup_header()
+        send_header(socket)
+        send_body(socket)
+      rescue Errno::EPIPE, Errno::ECONNRESET, Errno::ENOTCONN => ex
+        @logger.debug(ex)
+        @keep_alive = false
+      rescue Exception => ex
+        @logger.error(ex)
+        @keep_alive = false
+      end
+    end
+
+    def setup_header()
+      @reason_phrase    ||= HTTPStatus::reason_phrase(@status)
+      @header['server'] ||= @config[:ServerSoftware]
+      @header['date']   ||= Time.now.httpdate
+
+      # HTTP/0.9 features
+      if @request_http_version < "1.0"
+        @http_version = HTTPVersion.new("0.9")
+        @keep_alive = false
+      end
+
+      # HTTP/1.0 features
+      if @request_http_version < "1.1"
+        if chunked?
+          @chunked = false
+          ver = @request_http_version.to_s
+          msg = "chunked is set for an HTTP/#{ver} request. (ignored)"
+          @logger.warn(msg)
+        end
+      end
+
+      # Determine the message length (RFC2616 -- 4.4 Message Length)
+      if @status == 304 || @status == 204 || HTTPStatus::info?(@status)
+        @header.delete('content-length')
+        @body = ""
+      elsif chunked?
+        @header["transfer-encoding"] = "chunked"
+        @header.delete('content-length')
+      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.size : 0
+        end
+      end
+
+      # Keep-Alive connection.
+      if @header['connection'] == "close"
+         @keep_alive = false
+      elsif keep_alive?
+        if chunked? || @header['content-length']
+          @header['connection'] = "Keep-Alive"
+        end
+      else
+        @header['connection'] = "close"
+      end
+
+      # Location is a single absoluteURI.
+      if location = @header['location']
+        if @request_uri
+          @header['location'] = @request_uri.merge(location)
+        end
+      end
+    end
+
+    def send_header(socket)
+      if @http_version.major > 0
+        data = status_line()
+        @header.each{|key, value|
+          tmp = key.gsub(/\bwww|^te$|\b\w/){|s| s.upcase }
+          data << "#{tmp}: #{value}" << CRLF
+        }
+        @cookies.each{|cookie|
+          data << "Set-Cookie: " << cookie.to_s << CRLF
+        }
+        data << CRLF
+        _write_data(socket, data)
+      end
+    end
+
+    def send_body(socket)
+      case @body
+      when IO then send_body_io(socket)
+      else send_body_string(socket)
+      end
+    end
+
+    def to_s
+      ret = ""
+      send_response(ret)
+      ret
+    end
+
+    def set_redirect(status, url)
+      @body = "<HTML><A HREF=\"#{url.to_s}\">#{url.to_s}</A>.</HTML>\n"
+      @header['location'] = url.to_s
+      raise status
+    end
+
+    def set_error(ex, backtrace=false)
+      case ex
+      when HTTPStatus::Status 
+        @keep_alive = false if HTTPStatus::error?(ex.code)
+        self.status = ex.code
+      else 
+        @keep_alive = false
+        self.status = HTTPStatus::RC_INTERNAL_SERVER_ERROR
+      end
+      @header['content-type'] = "text/html; charset=ISO-8859-1"
+
+      if respond_to?(:create_error_page)
+        create_error_page()
+        return
+      end
+
+      if @request_uri
+        host, port = @request_uri.host, @request_uri.port
+      else
+        host, port = @config[:ServerName], @config[:Port]
+      end
+
+      @body = ''
+      @body << <<-_end_of_html_
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
+<HTML>
+  <HEAD><TITLE>#{HTMLUtils::escape(@reason_phrase)}</TITLE></HEAD>
+  <BODY>
+    <H1>#{HTMLUtils::escape(@reason_phrase)}</H1>
+    #{HTMLUtils::escape(ex.message)}
+    <HR>
+      _end_of_html_
+
+      if backtrace && $DEBUG
+        @body << "backtrace of `#{HTMLUtils::escape(ex.class.to_s)}' "
+        @body << "#{HTMLUtils::escape(ex.message)}"
+        @body << "<PRE>"
+        ex.backtrace.each{|line| @body << "\t#{line}\n"}
+        @body << "</PRE><HR>"
+      end
+
+      @body << <<-_end_of_html_
+    <ADDRESS>
+     #{HTMLUtils::escape(@config[:ServerSoftware])} at
+     #{host}:#{port}
+    </ADDRESS>
+  </BODY>
+</HTML>
+      _end_of_html_
+    end
+
+    private
+
+    def send_body_io(socket)
+      begin
+        if @request_method == "HEAD"
+          # do nothing
+        elsif chunked?
+          while buf = @body.read(BUFSIZE)
+            next if buf.empty?
+            data = ""
+            data << format("%x", buf.size) << CRLF
+            data << buf << CRLF
+            _write_data(socket, data)
+            @sent_size += buf.size
+          end
+          _write_data(socket, "0#{CRLF}#{CRLF}")
+        else
+          size = @header['content-length'].to_i
+          _send_file(socket, @body, 0, size)
+          @sent_size = size
+        end
+      ensure
+        @body.close
+      end
+    end
+
+    def send_body_string(socket)
+      if @request_method == "HEAD"
+        # do nothing
+      elsif chunked?
+        remain = body ? @body.size : 0
+        while buf = @body[@sent_size, BUFSIZE]
+          break if buf.empty?
+          data = ""
+          data << format("%x", buf.size) << CRLF
+          data << buf << CRLF
+          _write_data(socket, data)
+          @sent_size += buf.size
+        end
+        _write_data(socket, "0#{CRLF}#{CRLF}")
+      else
+        if @body && @body.size > 0
+          _write_data(socket, @body)
+          @sent_size = @body.size
+        end
+      end
+    end
+
+    def _send_file(output, input, offset, size)
+      while offset > 0
+        sz = BUFSIZE < offset ? BUFSIZE : offset
+        buf = input.read(sz)
+        offset -= buf.size
+      end
+
+      if size == 0
+        while buf = input.read(BUFSIZE)
+          _write_data(output, buf)
+        end
+      else
+        while size > 0
+          sz = BUFSIZE < size ? BUFSIZE : size
+          buf = input.read(sz)
+          _write_data(output, buf)
+          size -= buf.size
+        end
+      end
+    end
+
+    def _write_data(socket, data)
+      socket << data
+    end
+  end
+end