cyberweb 0.4.174

data/lib/cyberweb/cgi/mod_ruby_exception_printer.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+module Cyberweb
+
+require 'cyberweb/cgi/exceptions.rb'
+
+class CGI
+
+class ModRubyExceptionPrinter < ::Cyberweb::CGI::Exception
+
+  # ========================================================================= #
+  # === print_header
+  #
+  # print HTTP header (for mod_ruby)
+  # ========================================================================= #
+  def print_header
+    request = Apache::request # Request for when we use Apache.
+    request.status       = 500
+    request.status_line  = '500 Internal Error'
+    request.content_type = 'text/html'
+    request.headers_out['X-CGI-Exception'] = '0.3.0'
+    request.send_http_header
+  end
+
+  # ========================================================================= #
+  # === print_exception
+  #
+  # This method is responsible for printing the exception.
+  # ========================================================================= #
+  def print_exception(
+      the_exception
+    )
+    super
+    result = "#{the_exception.backtrace.first}: #{the_exception.message} (#{the_exception.class.name})\n"
+    $stderr.write(result)
+  end
+
+end; end; end

data/lib/cyberweb/cgi/query_extension.rb

@@ -0,0 +1,431 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# === Cyberweb::CGI::QueryExtension
+# =========================================================================== #
+module Cyberweb
+
+class CGI # === Cyberweb::CGI
+
+  require 'cyberweb/cgi/cookie.rb'
+
+  # ========================================================================= #
+  # === USE_OFFLINE_MODE
+  #
+  # The default is to have this constant set to true.
+  # ========================================================================= #
+  USE_OFFLINE_MODE = false
+
+  # ========================================================================= #
+  # === Cyberweb::CGI.use_commandline_input?
+  # ========================================================================= #
+  def self.use_commandline_input?
+    USE_OFFLINE_MODE
+  end
+
+  # ========================================================================= #
+  # === Cyberweb::CGI::QueryExtension
+  #
+  # 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
+
+    # ======================================================================= #
+    # === cookies
+    #
+    # Get the cookies as a hash of cookie-name=>Cookie pairs.
+    # ======================================================================= #
+    attr_accessor :cookies
+
+    # ======================================================================= #
+    # === params
+    #
+    # Get the parameters as a hash of name=>values pairs, where
+    # values is an Array.
+    # ======================================================================= #
+    attr_reader :params
+
+    # ======================================================================= #
+    # === files
+    #
+    # Get the uploaded files as a hash of name=>values pairs
+    # ======================================================================= #
+    attr_reader :files
+
+    # ======================================================================= #
+    # Defined two methods next.
+    # ======================================================================= #
+    %w( CONTENT_LENGTH SERVER_PORT ).each { |env|
+      define_method(env.sub(/^HTTP_/, '').downcase) {
+        (val = env_table[env]) && Integer(val)
+      }
+    }
+    # ======================================================================= #
+    # Define several methods next, depending on the predefined environment
+    # variables.
+    # ======================================================================= #
+    ARRAY_PREDEFINED_CGI_ENV_VARIABLES.each { |env|
+      define_method(env.sub(/^HTTP_/, '').downcase) {
+        env_table[env]
+      }
+    }
+
+    # ======================================================================= #
+    # === use_commandline_input?
+    # ======================================================================= #
+    def use_commandline_input?
+      ::Cyberweb::CGI.use_commandline_input?
+    end
+
+    # ========================================================================= #
+    # === raw_cookie
+    #
+    # Get the raw cookies as a string.
+    # ========================================================================= #
+    def raw_cookie
+      env_table['HTTP_COOKIE']
+    end
+
+    # ========================================================================= #
+    # === raw_cookie2
+    #
+    # Get the raw RFC2965 cookies as a string.
+    # ========================================================================= #
+    def raw_cookie2
+      env_table['HTTP_COOKIE2']
+    end
+
+    # ======================================================================= #
+    # === params=
+    #
+    # Set all the parameters. We should pass a Hash to this method.
+    # ======================================================================= #
+    def params=(hash)
+      @params.clear
+      @params.update(hash)
+    end
+
+    # ======================================================================= #
+    # === read_multipart
+    #
+    # 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
+      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.is_a?(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.close! if defined?(Tempfile) && body.is_a?(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
+    rescue Exception
+      if tempfiles
+        tempfiles.each {|t|
+          if t.path
+            t.close!
+          end
+        }
+      end
+      raise
+    end; private :read_multipart # read_multipart
+
+    # ======================================================================= #
+    # === create_body
+    # ======================================================================= #
+    def create_body(is_large)
+      if is_large
+        require 'tempfile'
+        body = Tempfile.new('CGI', encoding: Encoding::ASCII_8BIT)
+      else
+        begin
+          require 'stringio'
+          body = StringIO.new(''.force_encoding(Encoding::ASCII_8BIT))
+        rescue LoadError
+          require 'tempfile'
+          body = Tempfile.new('CGI', encoding: Encoding::ASCII_8BIT)
+        end
+      end
+      body.binmode if defined? body.binmode
+      return body
+    end
+
+    # ======================================================================= #
+    # === unescape_filename?
+    # ======================================================================= #
+    def unescape_filename?
+      user_agent = $CGI_ENV['HTTP_USER_AGENT']
+      return /Mac/i.match(user_agent) && /Mozilla/i.match(user_agent) && !/MSIE/i.match(user_agent)
+    end
+
+    # ========================================================================= #
+    # === keys
+    #
+    # Return all query parameter names as an array of String.
+    # ========================================================================= #
+    def keys(*i)
+      @params.keys(*i)
+    end
+
+    # ========================================================================= #
+    # === has_key?
+    #
+    # Returns true if a given query string parameter exists.
+    # ========================================================================= #
+    def has_key?(*i)
+      @params.has_key?(*i)
+    end; alias key?     has_key? # === key?
+         alias include? has_key? # === include?
+
+    # ======================================================================= #
+    # === read_from_cmdline
+    #
+    # Offline mode for CGI. read name=value pairs on standard input.
+    # ======================================================================= #
+    def read_from_cmdline
+      require 'shellwords'
+      string = unless ARGV.empty?
+        ARGV.join(' ')
+      else
+        if STDIN.tty?
+          _ = "(offline mode detected via STDIN.tty?: enter name=value pairs on standard input)\n"
+          STDERR.print(_)
+        end if USE_OFFLINE_MODE
+        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
+
+    # ========================================================================= #
+    # === multipart?
+    #
+    # Returns whether the form contained multipart/form-data
+    # ========================================================================= #
+    def multipart?
+      @multipart
+    end
+
+    # ======================================================================= #
+    # === initialize_query
+    #
+    # 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'])
+        current_max_multipart_length = @max_multipart_length.respond_to?(:call) ? @max_multipart_length.call : @max_multipart_length
+        if env_table['CONTENT_LENGTH'].to_i > current_max_multipart_length
+          raise StandardError.new('too large multipart data.')
+        end
+        boundary = $1.dup # Obtain the match element for the boundary.
+        @multipart = true
+        @params = read_multipart(boundary, Integer(env_table['CONTENT_LENGTH']))
+      else
+        @multipart = false
+        # =================================================================== #
+        # We have to obtain the available params next. We do this via
+        # CGI.parse().
+        # =================================================================== #
+        @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 # This may be empty here.
+                      read_from_cmdline if use_commandline_input?
+                    end.to_s.dup.force_encoding(@accept_charset)
+                  )
+        # =================================================================== #
+        # === Handle ASCII 8BIT Encoding next
+        # =================================================================== #
+        unless ::Encoding.find(@accept_charset) == ::Encoding::ASCII_8BIT
+          @params.each {|key,values|
+            values.each { |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
+      @cookies = ::Cyberweb::CGI::Cookie.parse((env_table['HTTP_COOKIE'] or env_table['COOKIE']))
+    end; private :initialize_query
+
+    # ========================================================================= #
+    # === []
+    #
+    # 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.first
+      if @multipart
+        if value
+          return value
+        elsif defined? StringIO
+          StringIO.new(''.force_encoding(::Encoding::ASCII_8BIT))
+        else
+          Tempfile.new('CGI', encoding: ::Encoding::ASCII_8BIT)
+        end
+      else
+        str = if value then value.dup else '' end
+        str
+      end
+    end
+
+  end # CGI::QueryExtension
+
+end; end

data/lib/cyberweb/cgi/session/file_store.rb

@@ -0,0 +1,131 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+module Cyberweb
+
+class CGI
+
+class Session # === Cyberweb::CGI::Session
+
+  # ======================================================================= #
+  # File-based session storage class.
+  #
+  # Implements session storage as a flat file of 'key=value' values.
+  # This storage type only works directly with String values; the
+  # user is responsible for converting other types to Strings when
+  # storing and from Strings when retrieving.
+  # ======================================================================= #
+  class FileStore
+    # Create a new FileStore instance.
+    #
+    # This constructor is used internally by CGI::Session.  The
+    # user does not generally need to call it directly.
+    #
+    # +session+ is the session for which this instance is being
+    # created.  The session id must only contain alphanumeric
+    # characters; automatically generated session ids observe
+    # this requirement.
+    #
+    # +option+ is a hash of options for the initializer.  The
+    # following options are recognised:
+    #
+    # tmpdir:: the directory to use for storing the FileStore
+    #          file.  Defaults to Dir::tmpdir (generally "/tmp"
+    #          on Unix systems).
+    # prefix:: the prefix to add to the session id when generating
+    #          the filename for this session's FileStore file.
+    #          Defaults to "cgi_sid_".
+    # suffix:: the prefix to add to the session id when generating
+    #          the filename for this session's FileStore file.
+    #          Defaults to the empty string.
+    #
+    # This session's FileStore file will be created if it does
+    # not exist, or opened if it does.
+    def initialize(session, option = {})
+      dir = option['tmpdir'] || Dir::tmpdir
+      prefix = option['prefix'] || 'cgi_sid_'
+      suffix = option['suffix'] || ''
+      id = session.session_id
+      require 'digest/md5'
+      md5 = Digest::MD5.hexdigest(id)[0,16]
+      @path = dir+"/"+prefix+md5+suffix
+      if File::exist? @path
+        @hash = nil
+      else
+        unless session.new_session
+          raise CGI::Session::NoSession, "uninitialized session"
+        end
+        @hash = {}
+      end
+    end
+
+    # === restore
+    #
+    # Restore session state from the session's FileStore file.
+    #
+    # Returns the session state as a hash.
+    def restore
+      unless @hash
+        @hash = {}
+        begin
+          lockf = File.open(@path+'.lock', 'r')
+          lockf.flock File::LOCK_SH
+          f = File.open(@path, 'r')
+          for line in f
+            line.chomp!
+            k, v = line.split('=',2)
+            @hash[CGI.unescape(k)] = Marshal.restore(CGI.unescape(v))
+          end
+        ensure
+          f.close unless f.nil?
+          lockf.close if lockf
+        end
+      end
+      @hash
+    end
+
+    # ======================================================================= #
+    # === update
+    #
+    # Save session state to the session's FileStore file.
+    # ======================================================================= #
+    def update
+      return unless @hash
+      begin
+        lockf = File.open(@path+".lock", File::CREAT|File::RDWR, 0600)
+        lockf.flock File::LOCK_EX
+        f = File.open(@path+".new", File::CREAT|File::TRUNC|File::WRONLY, 0600)
+        for k,v in @hash
+          f.printf "%s=%s\n", CGI::escape(k), CGI::escape(String(Marshal.dump(v)))
+        end
+        f.close
+        File.rename @path+".new", @path
+      ensure
+        f.close if f and !f.closed?
+        lockf.close if lockf
+      end
+    end
+
+    # ======================================================================= #
+    # === close
+    #
+    # Update and close the session's FileStore file.
+    # ======================================================================= #
+    def close
+      update
+    end
+
+    # ======================================================================= #
+    # === delete
+    #
+    # Close and delete the session's FileStore file.
+    # ======================================================================= #
+    def delete
+      File.unlink @path+'.lock' rescue nil
+      File.unlink @path+'.new' rescue nil
+      File.unlink @path rescue nil
+    end
+  end
+
+end; end; end

data/lib/cyberweb/cgi/session/memory_store.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+module Cyberweb
+
+class CGI
+
+class Session
+
+  # ======================================================================= #
+  # === MemoryStore
+  #
+  # In-memory session storage class.
+  #
+  # Implements session storage as a global in-memory hash.  Session
+  # data will only persist for as long as the Ruby interpreter
+  # instance does.
+  # ======================================================================= #
+  class MemoryStore
+
+    # ===================================================================== #
+    # === GLOBAL_HASH_TABLE
+    # ===================================================================== #
+    GLOBAL_HASH_TABLE = {} #:nodoc:
+
+    # ===================================================================== #
+    # === initialize
+    #
+    # Create a new MemoryStore instance.
+    #
+    # +session+ is the session this instance is associated with.
+    #
+    # +option+ is a list of initialisation options.  None are
+    # currently recognized.
+    # ===================================================================== #
+    def initialize(
+        session, option = nil
+      )
+      @session_id = session.session_id
+      unless GLOBAL_HASH_TABLE.key?(@session_id)
+        unless session.new_session
+          raise CGI::Session::NoSession, 'uninitialized session'
+        end
+        GLOBAL_HASH_TABLE[@session_id] = {}
+      end
+    end
+
+    # ===================================================================== #
+    # === restore
+    #
+    # Restore session state.
+    #
+    # Returns session data as a hash.
+    # ===================================================================== #
+    def restore
+      GLOBAL_HASH_TABLE[@session_id]
+    end
+
+    # ===================================================================== #
+    # === update
+    #
+    # Update session state.
+    #
+    # A no-op.
+    # ===================================================================== #
+    def update
+      # don't need to update; hash is shared
+    end
+
+    # ===================================================================== #
+    # Close session storage.
+    #
+    # A no-op.
+    # ===================================================================== #
+    def close
+      # don't need to close
+    end
+
+    # ===================================================================== #
+    # === delete
+    #
+    # Delete the session state.
+    # ===================================================================== #
+    def delete
+      GLOBAL_HASH_TABLE.delete(@session_id)
+    end
+  end
+
+end; end; end