rubysl-cgi 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ca1e8dbe8f76a7d86da0d860b5a3c41b53056b5b
-  data.tar.gz: f661b2e445100662dba142d2e30e383985c6b892
+  metadata.gz: a954e484bc04491a8e3a1b0c3cf1ae3215524f57
+  data.tar.gz: a6e590cf123f141d7d01118e29ae3e9ea41d59f2
 SHA512:
-  metadata.gz: c81bd82dfec68d8f91b3957375fb0484e3dce0da709d168f839c85d5277f8df6bd1aebb6f373f1f35a1f1b24b687de64a703392c3a6471d0aff8de1b122e0fcf
-  data.tar.gz: 760e91d5984724defc82b925025fcc9a0f205a3e32c48db01f4da306d47bb34c73591ce12b685257c7b5c09ced959cbe4e667106882fffe86e2f90229ebcaeb6
+  metadata.gz: 550528ca4b546b3d0a8e2c0e035df813d75c01ccab75f6499cfc27603f7f53774fc610c12223f0454682de7edbe9515a91e464f0a78e6d454af92dacc10d28dd
+  data.tar.gz: c05811504f35f8ac07efb920d6f5a4065ad7675772ce294f718ecd91bc8efee849c4e650ebc363cee2a68434766fda77c857f2b51b5109da8dfbf2cc9f45b3a3

data/.gitignore

@@ -15,4 +15,3 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
-.rbx

data/.travis.yml

@@ -1,8 +1,7 @@
 language: ruby
-before_install:
-  - gem update --system
-  - gem --version
-  - gem install rubysl-bundler
-script: bundle exec mspec spec
+env:
+  - RUBYLIB=lib
+script: bundle exec mspec
 rvm:
-  - rbx-nightly-18mode
+  - 1.9.3
+  - rbx-nightly-19mode

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Brian Shirai
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,4 +1,4 @@
-# RubySL::Cgi
+# Rubysl::Cgi
 
 TODO: Write a gem description
 
@@ -24,6 +24,6 @@ TODO: Write usage instructions here
 
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Added some feature'`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request

data/Rakefile

@@ -1,2 +1 @@
-#!/usr/bin/env rake
 require "bundler/gem_tasks"

data/lib/cgi/cookie.rb

@@ -0,0 +1,165 @@
+require 'cgi/util'
+class CGI
+  @@accept_charset="UTF-8" unless defined?(@@accept_charset)
+  # Class representing an HTTP cookie.
+  #
+  # In addition to its specific fields and methods, a Cookie instance
+  # is a delegator to the array of its values.
+  #
+  # See RFC 2965.
+  #
+  # == Examples of use
+  #   cookie1 = CGI::Cookie::new("name", "value1", "value2", ...)
+  #   cookie1 = CGI::Cookie::new("name" => "name", "value" => "value")
+  #   cookie1 = CGI::Cookie::new('name'    => 'name',
+  #                              'value'   => ['value1', 'value2', ...],
+  #                              'path'    => 'path',   # optional
+  #                              'domain'  => 'domain', # optional
+  #                              'expires' => Time.now, # optional
+  #                              'secure'  => true      # optional
+  #                             )
+  #
+  #   cgi.out("cookie" => [cookie1, cookie2]) { "string" }
+  #
+  #   name    = cookie1.name
+  #   values  = cookie1.value
+  #   path    = cookie1.path
+  #   domain  = cookie1.domain
+  #   expires = cookie1.expires
+  #   secure  = cookie1.secure
+  #
+  #   cookie1.name    = 'name'
+  #   cookie1.value   = ['value1', 'value2', ...]
+  #   cookie1.path    = 'path'
+  #   cookie1.domain  = 'domain'
+  #   cookie1.expires = Time.now + 30
+  #   cookie1.secure  = true
+  class Cookie < Array
+
+    # Create a new CGI::Cookie object.
+    #
+    # :call-seq:
+    #   Cookie.new(name_string,*value)
+    #   Cookie.new(options_hash)
+    #
+    # +name_string+::
+    #   The name of the cookie; in this form, there is no #domain or
+    #   #expiration.  The #path is gleaned from the +SCRIPT_NAME+ environment
+    #   variable, and #secure is false.
+    # <tt>*value</tt>::
+    #   value or list of values of the cookie
+    # +options_hash+::
+    #   A Hash of options to initialize this Cookie.  Possible options are:
+    #
+    #   name:: the name of the cookie.  Required.
+    #   value:: the cookie's value or list of values.
+    #   path:: the path for which this cookie applies.  Defaults to the
+    #          the value of the +SCRIPT_NAME+ environment variable.
+    #   domain:: the domain for which this cookie applies.
+    #   expires:: the time at which this cookie expires, as a +Time+ object.
+    #   secure:: whether this cookie is a secure cookie or not (default to
+    #            false).  Secure cookies are only transmitted to HTTPS
+    #            servers.
+    #
+    #   These keywords correspond to attributes of the cookie object.
+    def initialize(name = "", *value)
+      @domain = nil
+      @expires = nil
+      if name.kind_of?(String)
+        @name = name
+        %r|^(.*/)|.match(ENV["SCRIPT_NAME"])
+        @path = ($1 or "")
+        @secure = false
+        return super(value)
+      end
+
+      options = name
+      unless options.has_key?("name")
+        raise ArgumentError, "`name' required"
+      end
+
+      @name = options["name"]
+      value = Array(options["value"])
+      # simple support for IE
+      if options["path"]
+        @path = options["path"]
+      else
+        %r|^(.*/)|.match(ENV["SCRIPT_NAME"])
+        @path = ($1 or "")
+      end
+      @domain = options["domain"]
+      @expires = options["expires"]
+      @secure = options["secure"] == true ? true : false
+
+      super(value)
+    end
+
+    # Name of this cookie, as a +String+
+    attr_accessor :name
+    # Path for which this cookie applies, as a +String+
+    attr_accessor :path
+    # Domain for which this cookie applies, as a +String+
+    attr_accessor :domain
+    # Time at which this cookie expires, as a +Time+
+    attr_accessor :expires
+    # True if this cookie is secure; false otherwise
+    attr_reader("secure")
+
+    # Returns the value or list of values for this cookie.
+    def value
+      self
+    end
+
+    # Replaces the value of this cookie with a new value or list of values.
+    def value=(val)
+      replace(Array(val))
+    end
+
+    # Set whether the Cookie is a secure cookie or not.
+    #
+    # +val+ must be a boolean.
+    def secure=(val)
+      @secure = val if val == true or val == false
+      @secure
+    end
+
+    # Convert the Cookie to its string representation.
+    def to_s
+      val = collect{|v| CGI::escape(v) }.join("&")
+      buf = "#{@name}=#{val}"
+      buf << "; domain=#{@domain}" if @domain
+      buf << "; path=#{@path}"     if @path
+      buf << "; expires=#{CGI::rfc1123_date(@expires)}" if @expires
+      buf << "; secure"            if @secure == true
+      buf
+    end
+
+  end # class Cookie
+
+  # Parse a raw cookie string into a hash of cookie-name=>Cookie
+  # pairs.
+  #
+  #   cookies = CGI::Cookie::parse("raw_cookie_string")
+  #     # { "name1" => cookie1, "name2" => cookie2, ... }
+  #
+  def Cookie::parse(raw_cookie)
+    cookies = Hash.new([])
+    return cookies unless raw_cookie
+
+    raw_cookie.split(/[;,]\s?/).each do |pairs|
+      name, values = pairs.split('=',2)
+      next unless name and values
+      name = CGI::unescape(name)
+      values ||= ""
+      values = values.split('&').collect{|v| CGI::unescape(v,@@accept_charset) }
+      if cookies.has_key?(name)
+        values = cookies[name].value + values
+      end
+      cookies[name] = Cookie::new(name, *values)
+    end
+
+    cookies
+  end
+end
+
+

data/lib/cgi/core.rb

@@ -0,0 +1,864 @@
+#--
+# Methods for generating HTML, parsing CGI-related parameters, and
+# generating HTTP responses.
+#++
+class CGI
+
+  $CGI_ENV = ENV    # for FCGI support
+
+  # String for carriage return
+  CR  = "\015"
+
+  # String for linefeed
+  LF  = "\012"
+
+  # Standard internet newline sequence
+  EOL = CR + LF
+
+  REVISION = '$Id$' #:nodoc:
+
+  # Whether processing will be required in binary vs text
+  NEEDS_BINMODE = File::BINARY != 0
+
+  # Path separators in different environments.
+  PATH_SEPARATOR = {'UNIX'=>'/', 'WINDOWS'=>'\\', 'MACINTOSH'=>':'}
+
+  # HTTP status codes.
+  HTTP_STATUS = {
+    "OK"                  => "200 OK",
+    "PARTIAL_CONTENT"     => "206 Partial Content",
+    "MULTIPLE_CHOICES"    => "300 Multiple Choices",
+    "MOVED"               => "301 Moved Permanently",
+    "REDIRECT"            => "302 Found",
+    "NOT_MODIFIED"        => "304 Not Modified",
+    "BAD_REQUEST"         => "400 Bad Request",
+    "AUTH_REQUIRED"       => "401 Authorization Required",
+    "FORBIDDEN"           => "403 Forbidden",
+    "NOT_FOUND"           => "404 Not Found",
+    "METHOD_NOT_ALLOWED"  => "405 Method Not Allowed",
+    "NOT_ACCEPTABLE"      => "406 Not Acceptable",
+    "LENGTH_REQUIRED"     => "411 Length Required",
+    "PRECONDITION_FAILED" => "412 Precondition Failed",
+    "SERVER_ERROR"        => "500 Internal Server Error",
+    "NOT_IMPLEMENTED"     => "501 Method Not Implemented",
+    "BAD_GATEWAY"         => "502 Bad Gateway",
+    "VARIANT_ALSO_VARIES" => "506 Variant Also Negotiates"
+  }
+
+  # :startdoc:
+
+  # Synonym for ENV.
+  def env_table
+    ENV
+  end
+
+  # Synonym for $stdin.
+  def stdinput
+    $stdin
+  end
+
+  # Synonym for $stdout.
+  def stdoutput
+    $stdout
+  end
+
+  private :env_table, :stdinput, :stdoutput
+
+  # Create an HTTP header block as a string.
+  #
+  # :call-seq:
+  #   http_header(content_type_string="text/html")
+  #   http_header(headers_hash)
+  #
+  # Includes the empty line that ends the header block.
+  #
+  # +content_type_string+::
+  #   If this form is used, this string is the <tt>Content-Type</tt>
+  # +headers_hash+::
+  #   A Hash of header values. The following header keys are recognized:
+  #
+  #   type:: The Content-Type header.  Defaults to "text/html"
+  #   charset:: The charset of the body, appended to the Content-Type header.
+  #   nph:: A boolean value.  If true, prepend protocol string and status
+  #         code, and date; and sets default values for "server" and
+  #         "connection" if not explicitly set.
+  #   status::
+  #     The HTTP status code as a String, returned as the Status header.  The
+  #     values are:
+  #
+  #     OK:: 200 OK
+  #     PARTIAL_CONTENT:: 206 Partial Content
+  #     MULTIPLE_CHOICES:: 300 Multiple Choices
+  #     MOVED:: 301 Moved Permanently
+  #     REDIRECT:: 302 Found
+  #     NOT_MODIFIED:: 304 Not Modified
+  #     BAD_REQUEST:: 400 Bad Request
+  #     AUTH_REQUIRED:: 401 Authorization Required
+  #     FORBIDDEN:: 403 Forbidden
+  #     NOT_FOUND:: 404 Not Found
+  #     METHOD_NOT_ALLOWED:: 405 Method Not Allowed
+  #     NOT_ACCEPTABLE:: 406 Not Acceptable
+  #     LENGTH_REQUIRED:: 411 Length Required
+  #     PRECONDITION_FAILED:: 412 Precondition Failed
+  #     SERVER_ERROR:: 500 Internal Server Error
+  #     NOT_IMPLEMENTED:: 501 Method Not Implemented
+  #     BAD_GATEWAY:: 502 Bad Gateway
+  #     VARIANT_ALSO_VARIES:: 506 Variant Also Negotiates
+  #
+  #   server:: The server software, returned as the Server header.
+  #   connection:: The connection type, returned as the Connection header (for
+  #                instance, "close".
+  #   length:: The length of the content that will be sent, returned as the
+  #            Content-Length header.
+  #   language:: The language of the content, returned as the Content-Language
+  #              header.
+  #   expires:: The time on which the current content expires, as a +Time+
+  #             object, returned as the Expires header.
+  #   cookie::
+  #     A cookie or cookies, returned as one or more Set-Cookie headers.  The
+  #     value can be the literal string of the cookie; a CGI::Cookie object;
+  #     an Array of literal cookie strings or Cookie objects; or a hash all of
+  #     whose values are literal cookie strings or Cookie objects.
+  #
+  #     These cookies are in addition to the cookies held in the
+  #     @output_cookies field.
+  #
+  #   Other headers can also be set; they are appended as key: value.
+  #
+  # Examples:
+  #
+  #   http_header
+  #     # Content-Type: text/html
+  #
+  #   http_header("text/plain")
+  #     # Content-Type: text/plain
+  #
+  #   http_header("nph"        => true,
+  #               "status"     => "OK",  # == "200 OK"
+  #                 # "status"     => "200 GOOD",
+  #               "server"     => ENV['SERVER_SOFTWARE'],
+  #               "connection" => "close",
+  #               "type"       => "text/html",
+  #               "charset"    => "iso-2022-jp",
+  #                 # Content-Type: text/html; charset=iso-2022-jp
+  #               "length"     => 103,
+  #               "language"   => "ja",
+  #               "expires"    => Time.now + 30,
+  #               "cookie"     => [cookie1, cookie2],
+  #               "my_header1" => "my_value"
+  #               "my_header2" => "my_value")
+  #
+  # This method does not perform charset conversion.
+  def http_header(options='text/html')
+    if options.is_a?(String)
+      content_type = options
+      buf = _header_for_string(content_type)
+    elsif options.is_a?(Hash)
+      if options.size == 1 && options.has_key?('type')
+        content_type = options['type']
+        buf = _header_for_string(content_type)
+      else
+        buf = _header_for_hash(options.dup)
+      end
+    else
+      raise ArgumentError.new("expected String or Hash but got #{options.class}")
+    end
+    if defined?(MOD_RUBY)
+      _header_for_modruby(buf)
+      return ''
+    else
+      buf << EOL    # empty line of separator
+      return buf
+    end
+  end # http_header()
+
+  # This method is an alias for #http_header, when HTML5 tag maker is inactive.
+  #
+  # NOTE: use #http_header to create HTTP header blocks, this alias is only
+  # provided for backwards compatibility.
+  #
+  # Using #header with the HTML5 tag maker will create a <header> element.
+  alias :header :http_header
+
+  def _header_for_string(content_type) #:nodoc:
+    buf = ''
+    if nph?()
+      buf << "#{$CGI_ENV['SERVER_PROTOCOL'] || 'HTTP/1.0'} 200 OK#{EOL}"
+      buf << "Date: #{CGI.rfc1123_date(Time.now)}#{EOL}"
+      buf << "Server: #{$CGI_ENV['SERVER_SOFTWARE']}#{EOL}"
+      buf << "Connection: close#{EOL}"
+    end
+    buf << "Content-Type: #{content_type}#{EOL}"
+    if @output_cookies
+      @output_cookies.each {|cookie| buf << "Set-Cookie: #{cookie}#{EOL}" }
+    end
+    return buf
+  end # _header_for_string
+  private :_header_for_string
+
+  def _header_for_hash(options)  #:nodoc:
+    buf = ''
+    ## add charset to option['type']
+    options['type'] ||= 'text/html'
+    charset = options.delete('charset')
+    options['type'] += "; charset=#{charset}" if charset
+    ## NPH
+    options.delete('nph') if defined?(MOD_RUBY)
+    if options.delete('nph') || nph?()
+      protocol = $CGI_ENV['SERVER_PROTOCOL'] || 'HTTP/1.0'
+      status = options.delete('status')
+      status = HTTP_STATUS[status] || status || '200 OK'
+      buf << "#{protocol} #{status}#{EOL}"
+      buf << "Date: #{CGI.rfc1123_date(Time.now)}#{EOL}"
+      options['server'] ||= $CGI_ENV['SERVER_SOFTWARE'] || ''
+      options['connection'] ||= 'close'
+    end
+    ## common headers
+    status = options.delete('status')
+    buf << "Status: #{HTTP_STATUS[status] || status}#{EOL}" if status
+    server = options.delete('server')
+    buf << "Server: #{server}#{EOL}" if server
+    connection = options.delete('connection')
+    buf << "Connection: #{connection}#{EOL}" if connection
+    type = options.delete('type')
+    buf << "Content-Type: #{type}#{EOL}" #if type
+    length = options.delete('length')
+    buf << "Content-Length: #{length}#{EOL}" if length
+    language = options.delete('language')
+    buf << "Content-Language: #{language}#{EOL}" if language
+    expires = options.delete('expires')
+    buf << "Expires: #{CGI.rfc1123_date(expires)}#{EOL}" if expires
+    ## cookie
+    if cookie = options.delete('cookie')
+      case cookie
+      when String, Cookie
+        buf << "Set-Cookie: #{cookie}#{EOL}"
+      when Array
+        arr = cookie
+        arr.each {|c| buf << "Set-Cookie: #{c}#{EOL}" }
+      when Hash
+        hash = cookie
+        hash.each {|name, c| buf << "Set-Cookie: #{c}#{EOL}" }
+      end
+    end
+    if @output_cookies
+      @output_cookies.each {|c| buf << "Set-Cookie: #{c}#{EOL}" }
+    end
+    ## other headers
+    options.each do |key, value|
+      buf << "#{key}: #{value}#{EOL}"
+    end
+    return buf
+  end # _header_for_hash
+  private :_header_for_hash
+
+  def nph?  #:nodoc:
+    return /IIS\/(\d+)/.match($CGI_ENV['SERVER_SOFTWARE']) && $1.to_i < 5
+  end
+
+  def _header_for_modruby(buf)  #:nodoc:
+    request = Apache::request
+    buf.scan(/([^:]+): (.+)#{EOL}/o) do |name, value|
+      warn sprintf("name:%s value:%s\n", name, value) if $DEBUG
+      case name
+      when 'Set-Cookie'
+        request.headers_out.add(name, value)
+      when /^status$/i
+        request.status_line = value
+        request.status = value.to_i
+      when /^content-type$/i
+        request.content_type = value
+      when /^content-encoding$/i
+        request.content_encoding = value
+      when /^location$/i
+        request.status = 302 if request.status == 200
+        request.headers_out[name] = value
+      else
+        request.headers_out[name] = value
+      end
+    end
+    request.send_http_header
+    return ''
+  end
+  private :_header_for_modruby
+
+  # Print an HTTP header and body to $DEFAULT_OUTPUT ($>)
+  #
+  # :call-seq:
+  #   cgi.out(content_type_string='text/html')
+  #   cgi.out(headers_hash)
+  #
+  # +content_type_string+::
+  #   If a string is passed, it is assumed to be the content type.
+  # +headers_hash+::
+  #   This is a Hash of headers, similar to that used by #http_header.
+  # +block+::
+  #   A block is required and should evaluate to the body of the response.
+  #
+  # <tt>Content-Length</tt> is automatically calculated from the size of
+  # the String returned by the content block.
+  #
+  # If <tt>ENV['REQUEST_METHOD'] == "HEAD"</tt>, then only the header
+  # is output (the content block is still required, but it is ignored).
+  #
+  # If the charset is "iso-2022-jp" or "euc-jp" or "shift_jis" then the
+  # content is converted to this charset, and the language is set to "ja".
+  #
+  # Example:
+  #
+  #   cgi = CGI.new
+  #   cgi.out{ "string" }
+  #     # Content-Type: text/html
+  #     # Content-Length: 6
+  #     #
+  #     # string
+  #
+  #   cgi.out("text/plain") { "string" }
+  #     # Content-Type: text/plain
+  #     # Content-Length: 6
+  #     #
+  #     # string
+  #
+  #   cgi.out("nph"        => true,
+  #           "status"     => "OK",  # == "200 OK"
+  #           "server"     => ENV['SERVER_SOFTWARE'],
+  #           "connection" => "close",
+  #           "type"       => "text/html",
+  #           "charset"    => "iso-2022-jp",
+  #             # Content-Type: text/html; charset=iso-2022-jp
+  #           "language"   => "ja",
+  #           "expires"    => Time.now + (3600 * 24 * 30),
+  #           "cookie"     => [cookie1, cookie2],
+  #           "my_header1" => "my_value",
+  #           "my_header2" => "my_value") { "string" }
+  #      # HTTP/1.1 200 OK
+  #      # Date: Sun, 15 May 2011 17:35:54 GMT
+  #      # Server: Apache 2.2.0
+  #      # Connection: close
+  #      # Content-Type: text/html; charset=iso-2022-jp
+  #      # Content-Length: 6
+  #      # Content-Language: ja
+  #      # Expires: Tue, 14 Jun 2011 17:35:54 GMT
+  #      # Set-Cookie: foo
+  #      # Set-Cookie: bar
+  #      # my_header1: my_value
+  #      # my_header2: my_value
+  #      #
+  #      # string
+  def out(options = "text/html") # :yield:
+
+    options = { "type" => options } if options.kind_of?(String)
+    content = yield
+    options["length"] = content.bytesize.to_s
+    output = stdoutput
+    output.binmode if defined? output.binmode
+    output.print http_header(options)
+    output.print content unless "HEAD" == env_table['REQUEST_METHOD']
+  end
+
+
+  # Print an argument or list of arguments to the default output stream
+  #
+  #   cgi = CGI.new
+  #   cgi.print    # default:  cgi.print == $DEFAULT_OUTPUT.print
+  def print(*options)
+    stdoutput.print(*options)
+  end
+
+  # Parse an HTTP query string into a hash of key=>value pairs.
+  #
+  #   params = CGI::parse("query_string")
+  #     # {"name1" => ["value1", "value2", ...],
+  #     #  "name2" => ["value1", "value2", ...], ... }
+  #
+  def CGI::parse(query)
+    params = {}
+    query.split(/[&;]/).each do |pairs|
+      key, value = pairs.split('=',2).collect{|v| CGI::unescape(v) }
+
+      next unless key
+
+      params[key] ||= []
+      params[key].push(value) if value
+    end
+
+    params.default=[].freeze
+    params
+  end
+
+  # Maximum content length of post data
+  ##MAX_CONTENT_LENGTH  = 2 * 1024 * 1024
+
+  # Maximum content length of multipart data
+  MAX_MULTIPART_LENGTH  = 128 * 1024 * 1024
+
+  # Maximum number of request parameters when multipart
+  MAX_MULTIPART_COUNT = 128
+
+  # Mixin module that provides the following:
+  #
+  # 1. Access to the CGI environment variables as methods.  See
+  #    documentation to the CGI class for a list of these variables.  The
+  #    methods are exposed by removing the leading +HTTP_+ (if it exists) and
+  #    downcasing the name.  For example, +auth_type+ will return the
+  #    environment variable +AUTH_TYPE+, and +accept+ will return the value
+  #    for +HTTP_ACCEPT+.
+  #
+  # 2. Access to cookies, including the cookies attribute.
+  #
+  # 3. Access to parameters, including the params attribute, and overloading
+  #    #[] to perform parameter value lookup by key.
+  #
+  # 4. The initialize_query method, for initializing the above
+  #    mechanisms, handling multipart forms, and allowing the
+  #    class to be used in "offline" mode.
+  #
+  module QueryExtension
+
+    %w[ CONTENT_LENGTH SERVER_PORT ].each do |env|
+      define_method(env.sub(/^HTTP_/, '').downcase) do
+        (val = env_table[env]) && Integer(val)
+      end
+    end
+
+    %w[ AUTH_TYPE CONTENT_TYPE GATEWAY_INTERFACE PATH_INFO
+        PATH_TRANSLATED QUERY_STRING REMOTE_ADDR REMOTE_HOST
+        REMOTE_IDENT REMOTE_USER REQUEST_METHOD SCRIPT_NAME
+        SERVER_NAME SERVER_PROTOCOL SERVER_SOFTWARE
+
+        HTTP_ACCEPT HTTP_ACCEPT_CHARSET HTTP_ACCEPT_ENCODING
+        HTTP_ACCEPT_LANGUAGE HTTP_CACHE_CONTROL HTTP_FROM HTTP_HOST
+        HTTP_NEGOTIATE HTTP_PRAGMA HTTP_REFERER HTTP_USER_AGENT ].each do |env|
+      define_method(env.sub(/^HTTP_/, '').downcase) do
+        env_table[env]
+      end
+    end
+
+    # Get the raw cookies as a string.
+    def raw_cookie
+      env_table["HTTP_COOKIE"]
+    end
+
+    # Get the raw RFC2965 cookies as a string.
+    def raw_cookie2
+      env_table["HTTP_COOKIE2"]
+    end
+
+    # Get the cookies as a hash of cookie-name=>Cookie pairs.
+    attr_accessor :cookies
+
+    # Get the parameters as a hash of name=>values pairs, where
+    # values is an Array.
+    attr_reader :params
+
+    # Get the uploaded files as a hash of name=>values pairs
+    attr_reader :files
+
+    # Set all the parameters.
+    def params=(hash)
+      @params.clear
+      @params.update(hash)
+    end
+
+    ##
+    # Parses multipart form elements according to
+    #   http://www.w3.org/TR/html401/interact/forms.html#h-17.13.4.2
+    #
+    # Returns a hash of multipart form parameters with bodies of type StringIO or
+    # Tempfile depending on whether the multipart form element exceeds 10 KB
+    #
+    #   params[name => body]
+    #
+    def read_multipart(boundary, content_length)
+      ## read first boundary
+      stdin = stdinput
+      first_line = "--#{boundary}#{EOL}"
+      content_length -= first_line.bytesize
+      status = stdin.read(first_line.bytesize)
+      raise EOFError.new("no content body")  unless status
+      raise EOFError.new("bad content body") unless first_line == status
+      ## parse and set params
+      params = {}
+      @files = {}
+      boundary_rexp = /--#{Regexp.quote(boundary)}(#{EOL}|--)/
+      boundary_size = "#{EOL}--#{boundary}#{EOL}".bytesize
+      boundary_end  = nil
+      buf = ''
+      bufsize = 10 * 1024
+      max_count = MAX_MULTIPART_COUNT
+      n = 0
+      tempfiles = []
+      while true
+        (n += 1) < max_count or raise StandardError.new("too many parameters.")
+        ## create body (StringIO or Tempfile)
+        body = create_body(bufsize < content_length)
+        tempfiles << body if defined?(Tempfile) && body.kind_of?(Tempfile)
+        class << body
+          if method_defined?(:path)
+            alias local_path path
+          else
+            def local_path
+              nil
+            end
+          end
+          attr_reader :original_filename, :content_type
+        end
+        ## find head and boundary
+        head = nil
+        separator = EOL * 2
+        until head && matched = boundary_rexp.match(buf)
+          if !head && pos = buf.index(separator)
+            len  = pos + EOL.bytesize
+            head = buf[0, len]
+            buf  = buf[(pos+separator.bytesize)..-1]
+          else
+            if head && buf.size > boundary_size
+              len = buf.size - boundary_size
+              body.print(buf[0, len])
+              buf[0, len] = ''
+            end
+            c = stdin.read(bufsize < content_length ? bufsize : content_length)
+            raise EOFError.new("bad content body") if c.nil? || c.empty?
+            buf << c
+            content_length -= c.bytesize
+          end
+        end
+        ## read to end of boundary
+        m = matched
+        len = m.begin(0)
+        s = buf[0, len]
+        if s =~ /(\r?\n)\z/
+          s = buf[0, len - $1.bytesize]
+        end
+        body.print(s)
+        buf = buf[m.end(0)..-1]
+        boundary_end = m[1]
+        content_length = -1 if boundary_end == '--'
+        ## reset file cursor position
+        body.rewind
+        ## original filename
+        /Content-Disposition:.* filename=(?:"(.*?)"|([^;\r\n]*))/i.match(head)
+        filename = $1 || $2 || ''
+        filename = CGI.unescape(filename) if unescape_filename?()
+        body.instance_variable_set(:@original_filename, filename.taint)
+        ## content type
+        /Content-Type: (.*)/i.match(head)
+        (content_type = $1 || '').chomp!
+        body.instance_variable_set(:@content_type, content_type.taint)
+        ## query parameter name
+        /Content-Disposition:.* name=(?:"(.*?)"|([^;\r\n]*))/i.match(head)
+        name = $1 || $2 || ''
+        if body.original_filename.empty?
+          value=body.read.dup.force_encoding(@accept_charset)
+          body.unlink if defined?(Tempfile) && body.kind_of?(Tempfile)
+          (params[name] ||= []) << value
+          unless value.valid_encoding?
+            if @accept_charset_error_block
+              @accept_charset_error_block.call(name,value)
+            else
+              raise InvalidEncoding,"Accept-Charset encoding error"
+            end
+          end
+          class << params[name].last;self;end.class_eval do
+            define_method(:read){self}
+            define_method(:original_filename){""}
+            define_method(:content_type){""}
+          end
+        else
+          (params[name] ||= []) << body
+          @files[name]=body
+        end
+        ## break loop
+        break if content_length == -1
+      end
+      raise EOFError, "bad boundary end of body part" unless boundary_end =~ /--/
+      params.default = []
+      params
+    ensure
+      if $! && tempfiles
+        tempfiles.each {|t|
+          if t.path
+            t.unlink
+          end
+        }
+      end
+    end # read_multipart
+    private :read_multipart
+    def create_body(is_large)  #:nodoc:
+      if is_large
+        require 'tempfile'
+        body = Tempfile.new('CGI', encoding: "ascii-8bit")
+      else
+        begin
+          require 'stringio'
+          body = StringIO.new("".force_encoding("ascii-8bit"))
+        rescue LoadError
+          require 'tempfile'
+          body = Tempfile.new('CGI', encoding: "ascii-8bit")
+        end
+      end
+      body.binmode if defined? body.binmode
+      return body
+    end
+    def unescape_filename?  #:nodoc:
+      user_agent = $CGI_ENV['HTTP_USER_AGENT']
+      return /Mac/i.match(user_agent) && /Mozilla/i.match(user_agent) && !/MSIE/i.match(user_agent)
+    end
+
+    # offline mode. read name=value pairs on standard input.
+    def read_from_cmdline
+      require "shellwords"
+
+      string = unless ARGV.empty?
+        ARGV.join(' ')
+      else
+        if STDIN.tty?
+          STDERR.print(
+            %|(offline mode: enter name=value pairs on standard input)\n|
+          )
+        end
+        array = readlines rescue nil
+        if not array.nil?
+            array.join(' ').gsub(/\n/n, '')
+        else
+            ""
+        end
+      end.gsub(/\\=/n, '%3D').gsub(/\\&/n, '%26')
+
+      words = Shellwords.shellwords(string)
+
+      if words.find{|x| /=/n.match(x) }
+        words.join('&')
+      else
+        words.join('+')
+      end
+    end
+    private :read_from_cmdline
+
+    # A wrapper class to use a StringIO object as the body and switch
+    # to a TempFile when the passed threshold is passed.
+    # Initialize the data from the query.
+    #
+    # Handles multipart forms (in particular, forms that involve file uploads).
+    # Reads query parameters in the @params field, and cookies into @cookies.
+    def initialize_query()
+      if ("POST" == env_table['REQUEST_METHOD']) and
+         %r|\Amultipart/form-data.*boundary=\"?([^\";,]+)\"?|.match(env_table['CONTENT_TYPE'])
+        raise StandardError.new("too large multipart data.") if env_table['CONTENT_LENGTH'].to_i > MAX_MULTIPART_LENGTH
+        boundary = $1.dup
+        @multipart = true
+        @params = read_multipart(boundary, Integer(env_table['CONTENT_LENGTH']))
+      else
+        @multipart = false
+        @params = CGI::parse(
+                    case env_table['REQUEST_METHOD']
+                    when "GET", "HEAD"
+                      if defined?(MOD_RUBY)
+                        Apache::request.args or ""
+                      else
+                        env_table['QUERY_STRING'] or ""
+                      end
+                    when "POST"
+                      stdinput.binmode if defined? stdinput.binmode
+                      stdinput.read(Integer(env_table['CONTENT_LENGTH'])) or ''
+                    else
+                      read_from_cmdline
+                    end.dup.force_encoding(@accept_charset)
+                  )
+        unless Encoding.find(@accept_charset) == Encoding::ASCII_8BIT
+          @params.each do |key,values|
+            values.each do |value|
+              unless value.valid_encoding?
+                if @accept_charset_error_block
+                  @accept_charset_error_block.call(key,value)
+                else
+                  raise InvalidEncoding,"Accept-Charset encoding error"
+                end
+              end
+            end
+          end
+        end
+      end
+
+      @cookies = CGI::Cookie::parse((env_table['HTTP_COOKIE'] or env_table['COOKIE']))
+    end
+    private :initialize_query
+
+    # Returns whether the form contained multipart/form-data
+    def multipart?
+      @multipart
+    end
+
+    # Get the value for the parameter with a given key.
+    #
+    # If the parameter has multiple values, only the first will be
+    # retrieved; use #params to get the array of values.
+    def [](key)
+      params = @params[key]
+      return '' unless params
+      value = params[0]
+      if @multipart
+        if value
+          return value
+        elsif defined? StringIO
+          StringIO.new("".force_encoding("ascii-8bit"))
+        else
+          Tempfile.new("CGI",encoding:"ascii-8bit")
+        end
+      else
+        str = if value then value.dup else "" end
+        str
+      end
+    end
+
+    # Return all query parameter names as an array of String.
+    def keys(*args)
+      @params.keys(*args)
+    end
+
+    # Returns true if a given query string parameter exists.
+    def has_key?(*args)
+      @params.has_key?(*args)
+    end
+    alias key? has_key?
+    alias include? has_key?
+
+  end # QueryExtension
+
+  # Exception raised when there is an invalid encoding detected
+  class InvalidEncoding < Exception; end
+
+  # @@accept_charset is default accept character set.
+  # This default value default is "UTF-8"
+  # If you want to change the default accept character set
+  # when create a new CGI instance, set this:
+  #
+  #   CGI.accept_charset = "EUC-JP"
+  #
+  @@accept_charset="UTF-8"
+
+  # Return the accept character set for all new CGI instances.
+  def self.accept_charset
+    @@accept_charset
+  end
+
+  # Set the accept character set for all new CGI instances.
+  def self.accept_charset=(accept_charset)
+    @@accept_charset=accept_charset
+  end
+
+  # Return the accept character set for this CGI instance.
+  attr_reader :accept_charset
+
+  # Create a new CGI instance.
+  #
+  # :call-seq:
+  #   CGI.new(tag_maker) { block }
+  #   CGI.new(options_hash = {}) { block }
+  #
+  #
+  # <tt>tag_maker</tt>::
+  #   This is the same as using the +options_hash+ form with the value <tt>{
+  #   :tag_maker => tag_maker }</tt> Note that it is recommended to use the
+  #   +options_hash+ form, since it also allows you specify the charset you
+  #   will accept.
+  # <tt>options_hash</tt>::
+  #   A Hash that recognizes two options:
+  #
+  #   <tt>:accept_charset</tt>::
+  #     specifies encoding of received query string.  If omitted,
+  #     <tt>@@accept_charset</tt> is used.  If the encoding is not valid, a
+  #     CGI::InvalidEncoding will be raised.
+  #
+  #     Example. Suppose <tt>@@accept_charset</tt> is "UTF-8"
+  #
+  #     when not specified:
+  #
+  #         cgi=CGI.new      # @accept_charset # => "UTF-8"
+  #
+  #     when specified as "EUC-JP":
+  #
+  #         cgi=CGI.new(:accept_charset => "EUC-JP") # => "EUC-JP"
+  #
+  #   <tt>:tag_maker</tt>::
+  #     String that specifies which version of the HTML generation methods to
+  #     use.  If not specified, no HTML generation methods will be loaded.
+  #
+  #     The following values are supported:
+  #
+  #     "html3":: HTML 3.x
+  #     "html4":: HTML 4.0
+  #     "html4Tr":: HTML 4.0 Transitional
+  #     "html4Fr":: HTML 4.0 with Framesets
+  #     "html5":: HTML 5
+  #
+  # <tt>block</tt>::
+  #   If provided, the block is called when an invalid encoding is
+  #   encountered. For example:
+  #
+  #     encoding_errors={}
+  #     cgi=CGI.new(:accept_charset=>"EUC-JP") do |name,value|
+  #       encoding_errors[name] = value
+  #     end
+  #
+  # Finally, if the CGI object is not created in a standard CGI call
+  # environment (that is, it can't locate REQUEST_METHOD in its environment),
+  # then it will run in "offline" mode.  In this mode, it reads its parameters
+  # from the command line or (failing that) from standard input.  Otherwise,
+  # cookies and other parameters are parsed automatically from the standard
+  # CGI locations, which varies according to the REQUEST_METHOD.
+  def initialize(options = {}, &block) # :yields: name, value
+    @accept_charset_error_block = block_given? ? block : nil
+    @options={:accept_charset=>@@accept_charset}
+    case options
+    when Hash
+      @options.merge!(options)
+    when String
+      @options[:tag_maker]=options
+    end
+    @accept_charset=@options[:accept_charset]
+    if defined?(MOD_RUBY) && !ENV.key?("GATEWAY_INTERFACE")
+      Apache.request.setup_cgi_env
+    end
+
+    extend QueryExtension
+    @multipart = false
+
+    initialize_query()  # set @params, @cookies
+    @output_cookies = nil
+    @output_hidden = nil
+
+    case @options[:tag_maker]
+    when "html3"
+      require 'cgi/html'
+      extend Html3
+      element_init()
+      extend HtmlExtension
+    when "html4"
+      require 'cgi/html'
+      extend Html4
+      element_init()
+      extend HtmlExtension
+    when "html4Tr"
+      require 'cgi/html'
+      extend Html4Tr
+      element_init()
+      extend HtmlExtension
+    when "html4Fr"
+      require 'cgi/html'
+      extend Html4Tr
+      element_init()
+      extend Html4Fr
+      element_init()
+      extend HtmlExtension
+    when "html5"
+      require 'cgi/html'
+      extend Html5
+      element_init()
+      extend HtmlExtension
+    end
+  end
+
+end   # class CGI
+
+