cgialt 0.0.1 → 0.0.2

data/CHANGES.txt

@@ -0,0 +1,13 @@
+## $Rev$
+## 0.0.2
+## copyright(c) 2007 kuwata-lab.com all rights reserved.
+
+
+- release: 0.0.2
+  date: 2007-12-11
+  enhancements:
+    - FastCGI supported. If you required 'cgialt/fcgi' instead of 'fcgi',
+      you can use FCGI.each_cgi() method.
+
+- release: 0.0.1
+  date: 2007-12-09

data/README.txt

@@ -1,9 +1,11 @@
 = README.txt
 
-Release: 0.0.1
+Release: 0.0.2
 
 copyright(c) 2007 kuwata-lab.com all rights reserved.
 
+http://rubyforge.org/projects/cgialt/
+
 
 ==  About
 
@@ -17,14 +19,15 @@ It is written in pure Ruby but works faster than 'cgi.rb'.
 * Faster and more lightweight than 'cgi.rb'.
 * Available to install with CGIExt (which is a re-implementation of 'cgi.rb'
   in C extension).
+* FastCGI support
 
 
 ==  Install
 
-Download cgialt-0.0.1.tar.gz and install it according to the following:
+Download cgialt-0.0.2.tar.gz and install it according to the following:
 
-    $ tar xzf cgialt-0.0.1.tar.gz
-    $ cd cgialt-0.0.1/
+    $ tar xzf cgialt-0.0.2.tar.gz
+    $ cd cgialt-0.0.2/
     $ ruby setup.rb config
     $ ruby setup.rb setup
     $ sudo ruby setup.rb install
@@ -45,17 +48,24 @@ CGI class which is compatible with 'cgi.rb'.
    require 'rubygems'   # if you have installed with RubyGems
    require 'cgialt'
 
+If you want to use CGIAlt with FastCGI (fcgi.rb), require 'cgialt/fcgi'
+instead of 'fcgi'.
+
+   require 'cgialt'
+   require 'cgialt/fcgi'
+
 If you want to replace original 'cgi.rb' entirely by 'cgialt',
 create 'cgi.rb' which requires 'cgialt' under proper directory such as
 '/usr/local/lib/ruby/site_ruby/1.8'.
 
    $ sudo echo 'require "cgialt"' > /usr/local/lib/ruby/site_ruby/1.8/cgi.rb
+   $ sudo echo 'require "cgialt/fcgi"' > /usr/local/lib/ruby/site_ruby/1.8/fcgi.rb
 
 When $DEBUG is true or ENV['DEBUG'] is set, CGIAlt prints release number
 to $stderr when loaded.
 
    $ DEBUG=1 ruby -e 'require "cgi"'
-   *** CGIAlt: release 0.0.1
+   *** CGIAlt: release 0.0.2
 
 
 == Benchmark
@@ -92,8 +102,9 @@ The following is an example of benchmark.
     CGI#header (simple)                  6.0400    0.0100    6.0500 (   6.0553)
     CGI#header (complex)                36.2200    0.0400   36.2600 (  36.3138)
 
+
 It is good thing for performance to install CGIExt as well as CGIAlt.
-The following is an benchmark example of using both CGIAlt and CGIExt.
+The following is a benchmark example of using both CGIAlt and CGIExt.
 
     ## CGIAlt and CGIExt
     $ ruby -s bench.rb -N=1000 -cgialt -cgiext
@@ -110,16 +121,28 @@ The following is an benchmark example of using both CGIAlt and CGIExt.
     CGI#header (simple)                  6.0300    0.0100    6.0400 (   6.0651)
     CGI#header (complex)                36.5400    0.0800   36.6200 (  37.0642)
 
+
 The following is a summary of above benchmark results.
 
-     Table 1. summary of benchmark
-                                          cgi.rb      CGIAlt   CGIAlt+CGIExt
-     -----------------------------------------------------------------------
-     require "cgi"         (x1000)         13.16        7.89         9.18
-     CGI#new (simple)      (x100000)       20.34       14.53        12.46
-     CGI#new (comple)      (x100000)       26.62       20.10        13.19
-     CGI#header (simple)   (x1000000)      12.68        6.05         6.04
-     CGI#header (complex)  (x1000000)      43.52       36.26        36.62
+    Table 1. summary of benchmark
+                                       cgi.rb      CGIAlt        CGIAlt+CGIExt
+    ---------------------------------------------------------------------------
+    require "cgi"         (x1000)       13.16      7.89 ( 67%)      9.18 ( 43%)
+    CGI#new (simple)      (x100000)     20.34     14.53 ( 40%)     12.46 ( 63%)
+    CGI#new (comple)      (x100000)     26.62     20.10 ( 32%)     13.19 (102%)
+    CGI#header (simple)   (x1000000)    12.68      6.05 (110%)      6.04 (110%)
+    CGI#header (complex)  (x1000000)    43.52     36.26 ( 20%)     36.62 ( 19%)
+
+
+Another benchmark script 'bench.fcgi' is provided. It is for FastCGI.
+The following is an example result of benchmark.
+
+    Table 2. result of bench.fcgi
+                                   Time taken for tests     Request per second
+    --------------------------------------------------------------------------
+    cgi    + fcgi                          16.686 [sec]        1198.61 [#/sec]
+    cgialt + cgialt/fcgi                   15.562 [sec]        1285.18 [#/sec]
+    cgialt + cgialt/fcgi + cgiext          15.310 [sec]        1306.34 [#/sec]
 
 
 == License
@@ -127,7 +150,7 @@ The following is a summary of above benchmark results.
 Ruby's license
 
 
-== Authoer
+== Author
 
 makoto kuwata <kwa(at)kuwata-lab.com>
 

data/bench.rb

@@ -1,6 +1,6 @@
 ##
 ## $Rev: 30 $
-## $Release: 0.0.1 $
+## $Release: 0.0.2 $
 ## copyright(c) 2007 kuwata-lab.com all rights reserved.
 ##
 

data/lib/cgialt/cookie.rb

@@ -1,6 +1,4 @@
 ##
-## copyright(c) 2007 kuwata-lab.com all rights reserved.
-##
 ## Copyright (C) 2000  Network Applied Communication Laboratory, Inc.
 ##
 ## Copyright (C) 2000  Information-technology Promotion Agency, Japan
@@ -9,6 +7,9 @@
 ##
 ## Documentation: Wakou Aoyama (RDoc'd and embellished by William Webber)
 ##
+## $Rev: 32 $
+## $Release: 0.0.2 $
+## copyright(c) 2007 kuwata-lab.com all rights reserved.
 
 class CGI
 
@@ -77,13 +78,13 @@ class CGI
       if name.is_a?(String)
         @name = name
         @value = value  # value is an Array
-        @path = rexp.match(ENV['SCRIPT_NAME']) ? $& : ''
+        @path = rexp.match($CGI_ENV['SCRIPT_NAME']) ? $& : ''
         @secure = false
       else
         options = name
         @name  = options['name']  or raise ArgumentError, "`name' required"
         @value = Array(options['value'])
-        @path  = options['path'] || (rexp.match(ENV['SCRIPT_NAME']) ? $& : '')  # simple support for IE
+        @path  = options['path'] || (rexp.match($CGI_ENV['SCRIPT_NAME']) ? $& : '')  # simple support for IE
         @domain  = options['domain']
         @expires = options['expires']
         @secure  = options['secure'] == true

data/lib/cgialt/core.rb

@@ -1,6 +1,4 @@
 ##
-## copyright(c) 2007 kuwata-lab.com all rights reserved.
-##
 ## Copyright (C) 2000  Network Applied Communication Laboratory, Inc.
 ##
 ## Copyright (C) 2000  Information-technology Promotion Agency, Japan
@@ -9,6 +7,9 @@
 ##
 ## Documentation: Wakou Aoyama (RDoc'd and embellished by William Webber)
 ##
+## $Rev: 32 $
+## $Release: 0.0.2 $
+## copyright(c) 2007 kuwata-lab.com all rights reserved.
 
 raise "Please, use ruby 1.5.4 or later." if RUBY_VERSION < "1.5.4"
 
@@ -257,6 +258,8 @@ class CGI
 
   # :stopdoc:
 
+  $CGI_ENV = ENV    # for FCGI support
+
   EOL = "\r\n"
   #*** original
   #*# String for carriage return
@@ -268,7 +271,7 @@ class CGI
   #*# Standard internet newline sequence
   #*EOL = CR + LF
   #*
-  #*REVISION = '$Id: core.rb 27 2007-12-08 23:17:16Z kwatch $' #:nodoc:
+  #*REVISION = '$Id: core.rb 32 2007-12-11 04:22:35Z kwatch $' #:nodoc:
   #*
   #*NEEDS_BINMODE = true if /WIN/ni.match(RUBY_PLATFORM) 
   #*
@@ -309,14 +312,24 @@ class CGI
   def env_table
     ENV
   end
+  #*** original
+  #*def env_table
+  #*  ENV
+  #*end
+  #/*** original
 
   def stdinput
     $stdin
   end
 
   def stdoutput
-    $DEFAULT_OUTPUT
+    $stdout
   end
+  #*** original
+  #*def stdoutput
+  #*  $DEFAULT_OUTPUT
+  #*end
+  #*** /original
 
   private :env_table, :stdinput, :stdoutput
 
@@ -424,9 +437,9 @@ class CGI
   def _header_for_string(content_type) #:nodoc:
     buf = ''
     if nph?()
-      buf << "#{ENV['SERVER_PROTOCOL'] || 'HTTP/1.0'} 200 OK#{EOL}"
+      buf << "#{$CGI_ENV['SERVER_PROTOCOL'] || 'HTTP/1.0'} 200 OK#{EOL}"
       buf << "Date: #{CGI.rfc1123_date(Time.now)}#{EOL}"
-      buf << "Server: #{ENV['SERVER_SOFTWARE']}#{EOL}"
+      buf << "Server: #{$CGI_ENV['SERVER_SOFTWARE']}#{EOL}"
       buf << "Connection: close#{EOL}"
     end
     buf << "Content-Type: #{content_type}#{EOL}"
@@ -446,12 +459,12 @@ class CGI
     ## NPH
     options.delete('nph') if defined?(MOD_RUBY)
     if options.delete('nph') || nph?()
-      protocol = ENV['SERVER_PROTOCOL'] || 'HTTP/1.0'
+      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'] ||= ENV['SERVER_SOFTWARE'] || ''
+      options['server'] ||= $CGI_ENV['SERVER_SOFTWARE'] || ''
       options['connection'] ||= 'close'
     end
     ## common headers
@@ -494,7 +507,7 @@ class CGI
   private :_header_for_hash
 
   def nph?  #:nodoc:
-    return /IIS\/(\d+)/n.match(ENV['SERVER_SOFTWARE']) && $1.to_i < 5
+    return /IIS\/(\d+)/n.match($CGI_ENV['SERVER_SOFTWARE']) && $1.to_i < 5
   end
 
   def _header_for_modruby(buf)  #:nodoc:
@@ -702,7 +715,7 @@ class CGI
     content = convert_content(content, options)
     options['length'] = content.length.to_s
     stdout.print header(options)
-    stdout.print content unless ENV['REQUEST_METHOD'] == 'HEAD'
+    stdout.print content unless $CGI_ENV['REQUEST_METHOD'] == 'HEAD'
   end
   def convert_content(content, options)  #:nodoc:
     charset = options['charset']
@@ -823,88 +836,88 @@ class CGI
   module QueryExtension
 
     ## return Integer(ENV['CONTENT_LENGTH'])
-    def content_length    ; return Integer(ENV['CONTENT_LENGTH']) ; end
+    def content_length    ; return Integer($CGI_ENV['CONTENT_LENGTH']) ; end
 
     ## return Integer(ENV['SERVER_PORT'])
-    def server_port       ; return Integer(ENV['SERVER_PORT'])    ; end
+    def server_port       ; return Integer($CGI_ENV['SERVER_PORT'])    ; end
 
     ## return ENV['AUTH_TYPE']
-    def auth_type         ; return ENV['AUTH_TYPE']            ; end
+    def auth_type         ; return $CGI_ENV['AUTH_TYPE']            ; end
 
     ## return ENV['CONTENT_TYPE']
-    def content_type      ; return ENV['CONTENT_TYPE']         ; end
+    def content_type      ; return $CGI_ENV['CONTENT_TYPE']         ; end
 
     ## return ENV['GATEWAY_INTERFACE']
-    def gateway_interface ; return ENV['GATEWAY_INTERFACE']    ; end
+    def gateway_interface ; return $CGI_ENV['GATEWAY_INTERFACE']    ; end
 
     ## return ENV['PATH_INFO']
-    def path_info         ; return ENV['PATH_INFO']            ; end
+    def path_info         ; return $CGI_ENV['PATH_INFO']            ; end
 
     ## return ENV['PATH_TRANSLATED']
-    def path_translated   ; return ENV['PATH_TRANSLATED']      ; end
+    def path_translated   ; return $CGI_ENV['PATH_TRANSLATED']      ; end
 
     ## return ENV['QUERY_STRING']
-    def query_string      ; return ENV['QUERY_STRING']         ; end
+    def query_string      ; return $CGI_ENV['QUERY_STRING']         ; end
 
     ## return ENV['REMOTE_ADDR']
-    def remote_addr       ; return ENV['REMOTE_ADDR']          ; end
+    def remote_addr       ; return $CGI_ENV['REMOTE_ADDR']          ; end
 
     ## return ENV['REMOTE_HOST']
-    def remote_host       ; return ENV['REMOTE_HOST']          ; end
+    def remote_host       ; return $CGI_ENV['REMOTE_HOST']          ; end
 
     ## return ENV['REMOTE_IDENT']
-    def remote_ident      ; return ENV['REMOTE_IDENT']         ; end
+    def remote_ident      ; return $CGI_ENV['REMOTE_IDENT']         ; end
 
     ## return ENV['REMOTE_USER']
-    def remote_user       ; return ENV['REMOTE_USER']          ; end
+    def remote_user       ; return $CGI_ENV['REMOTE_USER']          ; end
 
     ## return ENV['REQUEST_METHOD']
-    def request_method    ; return ENV['REQUEST_METHOD']       ; end
+    def request_method    ; return $CGI_ENV['REQUEST_METHOD']       ; end
 
     ## return ENV['SCRIPT_NAME']
-    def script_name       ; return ENV['SCRIPT_NAME']          ; end
+    def script_name       ; return $CGI_ENV['SCRIPT_NAME']          ; end
 
     ## return ENV['SERVER_NAME']
-    def server_name       ; return ENV['SERVER_NAME']          ; end
+    def server_name       ; return $CGI_ENV['SERVER_NAME']          ; end
 
     ## return ENV['SERVER_PROTOCOL']
-    def server_protocol   ; return ENV['SERVER_PROTOCOL']      ; end
+    def server_protocol   ; return $CGI_ENV['SERVER_PROTOCOL']      ; end
 
     ## return ENV['SERVER_SOFTWARE']
-    def server_software   ; return ENV['SERVER_SOFTWARE']      ; end
+    def server_software   ; return $CGI_ENV['SERVER_SOFTWARE']      ; end
 
     ## return ENV['HTTP_ACCEPT']
-    def accept            ; return ENV['HTTP_ACCEPT']          ; end
+    def accept            ; return $CGI_ENV['HTTP_ACCEPT']          ; end
 
     ## return ENV['HTTP_ACCEPT_CHARSET']
-    def accept_charset    ; return ENV['HTTP_ACCEPT_CHARSET']  ; end
+    def accept_charset    ; return $CGI_ENV['HTTP_ACCEPT_CHARSET']  ; end
 
     ## return ENV['HTTP_ACCEPT_ENCODING']
-    def accept_encoding   ; return ENV['HTTP_ACCEPT_ENCODING'] ; end
+    def accept_encoding   ; return $CGI_ENV['HTTP_ACCEPT_ENCODING'] ; end
 
     ## return ENV['HTTP_ACCEPT_LANGUAGE']
-    def accept_language   ; return ENV['HTTP_ACCEPT_LANGUAGE'] ; end
+    def accept_language   ; return $CGI_ENV['HTTP_ACCEPT_LANGUAGE'] ; end
 
     ## return ENV['HTTP_CACHE_CONTROL']
-    def cache_control     ; return ENV['HTTP_CACHE_CONTROL']   ; end
+    def cache_control     ; return $CGI_ENV['HTTP_CACHE_CONTROL']   ; end
 
     ## return ENV['HTTP_FROM']
-    def from              ; return ENV['HTTP_FROM']            ; end
+    def from              ; return $CGI_ENV['HTTP_FROM']            ; end
 
     ## return ENV['HTTP_HOST']
-    def host              ; return ENV['HTTP_HOST']            ; end
+    def host              ; return $CGI_ENV['HTTP_HOST']            ; end
 
     ## return ENV['HTTP_NEGOTIATE']
-    def negotiate         ; return ENV['HTTP_NEGOTIATE']       ; end
+    def negotiate         ; return $CGI_ENV['HTTP_NEGOTIATE']       ; end
 
     ## return ENV['HTTP_PRAGMA']
-    def pragma            ; return ENV['HTTP_PRAGMA']          ; end
+    def pragma            ; return $CGI_ENV['HTTP_PRAGMA']          ; end
 
     ## return ENV['HTTP_REFERER']
-    def referer           ; return ENV['HTTP_REFERER']         ; end
+    def referer           ; return $CGI_ENV['HTTP_REFERER']         ; end
 
     ## return ENV['HTTP_USER_AGENT']
-    def user_agent        ; return ENV['HTTP_USER_AGENT']      ; end
+    def user_agent        ; return $CGI_ENV['HTTP_USER_AGENT']      ; end
 
     #*** orignal
     #*%w[ CONTENT_LENGTH SERVER_PORT ].each do |env|
@@ -929,7 +942,7 @@ class CGI
 
     # Get the raw cookies as a string.
     def raw_cookie
-      return ENV['HTTP_COOKIE']
+      return $CGI_ENV['HTTP_COOKIE']
     end
     #*** original
     #*def raw_cookie
@@ -939,7 +952,7 @@ class CGI
 
     # Get the raw RFC2965 cookies as a string.
     def raw_cookie2
-      return ENV['HTTP_COOKIE2']
+      return $CGI_ENV['HTTP_COOKIE2']
     end
     #*** original
     #*def raw_cookie2
@@ -1064,7 +1077,7 @@ class CGI
       return body
     end
     def unescape_filename?  #:nodoc:
-      user_agent = ENV['HTTP_USER_AGENT']
+      user_agent = $CGI_ENV['HTTP_USER_AGENT']
       return /Mac/ni.match(user_agent) && /Mozilla/ni.match(user_agent) && !/MSIE/ni.match(user_agent)
     end
     #*** original
@@ -1222,16 +1235,16 @@ class CGI
     # Handles multipart forms (in particular, forms that involve file uploads).
     # Reads query parameters in the @params field, and cookies into @cookies.
     def initialize_query()
-      case ENV['REQUEST_METHOD']
+      case $CGI_ENV['REQUEST_METHOD']
       when 'GET', 'HEAD'
-        query_str = defined?(MOD_RUBY) ? Apache::request.args : ENV['QUERY_STRING']
+        query_str = defined?(MOD_RUBY) ? Apache::request.args : $CGI_ENV['QUERY_STRING']
         @params = CGI.parse(query_str || '')
         @multipart = false
       when 'POST'
-        content_length = Integer(ENV['CONTENT_LENGTH'])
-        if /\Amultipart\/form-data/.match(ENV['CONTENT_TYPE'])
+        content_length = Integer($CGI_ENV['CONTENT_LENGTH'])
+        if /\Amultipart\/form-data/.match($CGI_ENV['CONTENT_TYPE'])
           raise StandardError.new("too large multipart data.") if content_length > MAX_MULTIPART_LENGTH
-          unless /boundary=(?:"([^";,]+?)"|([^;,\s]+))/.match(ENV['CONTENT_TYPE'])
+          unless /boundary=(?:"([^";,]+?)"|([^;,\s]+))/.match($CGI_ENV['CONTENT_TYPE'])
             raise StandardError.new("no boundary of multipart data.")
           end
           boundary = $1 || $2
@@ -1249,7 +1262,7 @@ class CGI
         @params = Hash.new([].freeze)
         @multipart = false
       end
-      @cookies = CGI::Cookie.parse(ENV['HTTP_COOKIE'] || ENV['COOKIE'])
+      @cookies = CGI::Cookie.parse($CGI_ENV['HTTP_COOKIE'] || $CGI_ENV['COOKIE'])
       nil
     end
     private :initialize_query
@@ -1383,7 +1396,7 @@ class CGI
   # cookies and other parameters are parsed automatically from the standard
   # CGI locations, which varies according to the REQUEST_METHOD.
   def initialize(type=nil)
-    if defined?(MOD_RUBY) && !ENV['GATEWAY_INTERFACE']
+    if defined?(MOD_RUBY) && !$CGI_ENV['GATEWAY_INTERFACE']
       Apache.request.setup_cgi_env
     end
     ##

data/lib/cgialt/fcgi/cgi_helper.rb

@@ -0,0 +1,102 @@
+##
+## $Rev: 33 $
+## $Release: 0.0.2 $
+## copyright(c) 2007 kuwata-lab.com all rights reserved.
+##
+
+=begin
+
+fcgi.rb 0.8.5 - fcgi.so compatible pure-ruby FastCGI library
+
+fastcgi.rb Copyright (C) 2001 Eli Green
+fcgi.rb    Copyright (C) 2002-2003 MoonWolf <moonwolf@moonwolf.com>
+fcgi.rb    Copyright (C) 2004 Minero Aoki
+
+=end
+
+require 'cgialt' unless defined?(CGI)
+
+class FCGI
+
+  if FCGI.is_cgi?
+    def FCGI.each_cgi(arg=nil)
+      #require 'cgialt' unless defined?(CGI)
+      yield CGI.new(arg)
+    end
+  else
+    def FCGI.each_cgi(arg=nil)
+      #require 'cgialt' unless defined?(CGI)
+      #exit_requested = false
+      FCGI.each do |request|
+        $FCGI_REQUEST = request
+        $stdout = request.out
+        $stderr = request.err
+        #ENV.clear
+        #ENV.update(request.env)
+        $CGI_ENV = request.env
+        yield CGI.new(arg)
+        request.finish
+      end
+    end
+  end
+
+end
+#*** original
+#*# There is no C version of 'each_cgi'
+#*# Note: for ruby-1.6.8 at least, the constants CGI_PARAMS/CGI_COOKIES
+#*# are defined within module 'CGI', even if you have subclassed it
+#*
+#*class FCGI
+#*  def self::each_cgi(*args)
+#*    require 'cgi'
+#*
+#*    eval(<<-EOS,TOPLEVEL_BINDING)
+#*    class CGI
+#*      public :env_table
+#*      def self::remove_params
+#*        if (const_defined?(:CGI_PARAMS))
+#*          remove_const(:CGI_PARAMS)
+#*          remove_const(:CGI_COOKIES)
+#*        end
+#*      end
+#*    end # ::CGI class
+#*
+#*    class FCGI
+#*      class CGI < ::CGI
+#*        def initialize(request, *args)
+#*          ::CGI.remove_params
+#*          @request = request
+#*          super(*args)
+#*          @args = *args
+#*        end
+#*        def args
+#*          @args
+#*        end
+#*        def env_table
+#*          @request.env
+#*        end
+#*        def stdinput
+#*          @request.in
+#*        end
+#*        def stdoutput
+#*          @request.out
+#*        end
+#*      end # FCGI::CGI class
+#*    end # FCGI class
+#*    EOS
+#*    
+#*    if FCGI::is_cgi?
+#*      yield ::CGI.new(*args)
+#*    else
+#*      exit_requested = false
+#*      FCGI::each {|request|
+#*        $stdout, $stderr = request.out, request.err
+#*
+#*        yield CGI.new(request, *args)
+#*        
+#*        request.finish
+#*      }
+#*    end
+#*  end
+#*end
+#*** /original

data/lib/cgialt/fcgi/core.rb

@@ -0,0 +1,561 @@
+##
+## $Rev: 33 $
+## $Release: 0.0.2 $
+## copyright(c) 2007 kuwata-lab.com all rights reserved.
+##
+
+=begin
+
+fcgi.rb 0.8.5 - fcgi.so compatible pure-ruby FastCGI library
+
+fastcgi.rb Copyright (C) 2001 Eli Green
+fcgi.rb    Copyright (C) 2002-2003 MoonWolf <moonwolf@moonwolf.com>
+fcgi.rb    Copyright (C) 2004 Minero Aoki
+
+=end
+
+
+  require 'socket'
+  require 'stringio'
+
+  class FCGI
+
+    def self::is_cgi?
+      begin
+        s = Socket.for_fd($stdin.fileno)
+        s.getpeername
+        false
+      rescue Errno::ENOTCONN
+        false
+      rescue Errno::ENOTSOCK, Errno::EINVAL
+        true
+      end
+    end
+
+    def self::each(&block)
+      f = default_connection()
+      Server.new(f).each_request(&block)
+    ensure
+      f.close if f
+    end
+
+    def self::each_request(&block)
+      f = default_connection()
+      Server.new(f).each_request(&block)
+    ensure
+      f.close if f
+    end
+
+    def self::default_connection
+      ::Socket.for_fd($stdin.fileno)
+    end
+
+
+
+    ProtocolVersion = 1
+
+    # Record types
+    FCGI_BEGIN_REQUEST = 1
+    FCGI_ABORT_REQUEST = 2
+    FCGI_END_REQUEST = 3
+    FCGI_PARAMS = 4
+    FCGI_STDIN = 5
+    FCGI_STDOUT = 6
+    FCGI_STDERR = 7
+    FCGI_DATA = 8
+    FCGI_GET_VALUES = 9
+    FCGI_GET_VALUES_RESULT = 10
+    FCGI_UNKNOWN_TYPE = 11
+    FCGI_MAXTYPE = FCGI_UNKNOWN_TYPE
+
+    FCGI_NULL_REQUEST_ID = 0
+
+    # FCGI_BEGIN_REQUSET.role
+    FCGI_RESPONDER = 1
+    FCGI_AUTHORIZER = 2
+    FCGI_FILTER = 3
+
+    # FCGI_BEGIN_REQUEST.flags
+    FCGI_KEEP_CONN = 1
+
+    # FCGI_END_REQUEST.protocolStatus
+    FCGI_REQUEST_COMPLETE = 0
+    FCGI_CANT_MPX_CONN = 1
+    FCGI_OVERLOADED = 2
+    FCGI_UNKNOWN_ROLE = 3
+
+
+    class Server
+
+      def initialize(server)
+        @server = server
+        @buffers = {}
+        @default_parameters = {
+          "FCGI_MAX_CONNS" => 1,
+          "FCGI_MAX_REQS"  => 1,
+          "FCGI_MPX_CONNS" => true
+        }
+      end
+
+      def each_request(&block)
+        graceful = false
+        trap("SIGUSR1") { graceful = true }
+        while true
+          begin
+            session(&block)
+          rescue Errno::EPIPE, EOFError
+            # HTTP request is canceled by the remote user
+          end
+          exit 0 if graceful
+        end
+      end
+      
+      def session
+        sock, addr = *@server.accept
+        return unless sock
+        fsock = FastCGISocket.new(sock)
+        req = next_request(fsock)
+        yield req
+        respond_to req, fsock, FCGI_REQUEST_COMPLETE
+      ensure
+        sock.close if sock and not sock.closed?
+      end
+
+      private
+
+      def next_request(sock)
+        while rec = sock.read_record
+          if rec.management_record?
+            case rec.type
+            when FCGI_GET_VALUES
+              sock.send_record handle_GET_VALUES(rec)
+            else
+              sock.send_record UnknownTypeRecord.new(rec.request_id, rec.type)
+            end
+          else
+            case rec.type
+            when FCGI_BEGIN_REQUEST
+              @buffers[rec.request_id] = RecordBuffer.new(rec)
+            when FCGI_ABORT_REQUEST
+              raise "got ABORT_REQUEST"   # FIXME
+            else
+              buf = @buffers[rec.request_id]   or next # inactive request
+              buf.push rec
+              if buf.ready?
+                @buffers.delete rec.request_id
+                return buf.new_request
+              end
+            end
+          end
+        end
+        raise "must not happen: FCGI socket unexpected EOF"
+      end
+
+      def handle_GET_VALUES(rec)
+        h = {}
+        rec.values.each_key do |name|
+          h[name] = @default_parameters[name]
+        end
+        ValuesRecord.new(FCGI_GET_VALUES_RESULT, rec.request_id, h)
+      end
+
+      def respond_to(req, sock, status)
+        split_data(FCGI_STDOUT, req.id, req.out) do |rec|
+          sock.send_record rec
+        end
+        split_data(FCGI_STDERR, req.id, req.err) do |rec|
+          sock.send_record rec
+        end if req.err.length > 0
+        sock.send_record EndRequestRecord.new(req.id, 0, status)
+      end
+
+      DATA_UNIT = 16384
+
+      def split_data(type, id, f)
+        unless f.length == 0
+          f.rewind
+          while s = f.read(DATA_UNIT)
+            yield GenericDataRecord.new(type, id, s)
+          end
+        end
+        yield GenericDataRecord.new(type, id, '')
+      end
+
+    end
+
+
+    class FastCGISocket
+      def initialize(sock)
+        @socket = sock
+      end
+
+      def read_record
+        header = @socket.read(Record::HEADER_LENGTH) or return nil
+        return nil unless header.size == Record::HEADER_LENGTH
+        version, type, reqid, clen, padlen, reserved = *Record.parse_header(header)
+        Record.class_for(type).parse(reqid, read_record_body(clen, padlen))
+      end
+
+      def read_record_body(clen, padlen)
+        buf = ''
+        while buf.length < clen
+          buf << @socket.read([1024, clen - buf.length].min)
+        end
+        @socket.read padlen if padlen
+        buf
+      end
+      private :read_record_body
+
+      def send_record(rec)
+        @socket.write rec.serialize
+        @socket.flush
+      end
+    end
+
+
+    class RecordBuffer
+      def initialize(rec)
+        @begin_request = rec
+        @envs = []
+        @stdins = []
+        @datas = []
+      end
+
+      def push(rec)
+        case rec
+        when ParamsRecord
+          @envs.push rec
+        when StdinDataRecord
+          @stdins.push rec
+        when DataRecord
+          @datas.push rec
+        else
+          raise "got unknown record: #{rec.class}"
+        end
+      end
+
+      def ready?
+        case @begin_request.role
+        when FCGI_RESPONDER
+          completed?(@envs) and
+          completed?(@stdins)
+        when FCGI_AUTHORIZER
+          completed?(@envs)
+        when FCGI_FILTER
+          completed?(@envs) and
+          completed?(@stdins) and
+          completed?(@datas)
+        else
+          raise "unknown role: #{@begin_request.role}"
+        end
+      end
+
+      def completed?(records)
+        records.last and records.last.empty?
+      end
+      private :completed?
+
+      def new_request
+        Request.new(@begin_request.request_id, env(), stdin(), nil, nil, data())
+      end
+
+      def env
+        h = {}
+        @envs.each {|rec| h.update rec.values }
+        h
+      end
+
+      def stdin
+        StringIO.new(@stdins.inject('') {|buf, rec| buf << rec.flagment })
+      end
+
+      def data
+        StringIO.new(@datas.inject('') {|buf, rec| buf << rec.flagment })
+      end
+    end
+
+
+    class Request
+      def initialize(id, env, stdin, stdout = nil, stderr = nil, data = nil)
+        @id = id
+        @env = env
+        @in = stdin
+        @out = stdout || StringIO.new
+        @err = stderr || StringIO.new
+        @data = data || StringIO.new
+      end
+
+      attr_reader :id
+      attr_reader :env
+      attr_reader :in
+      attr_reader :out
+      attr_reader :err
+      attr_reader :data
+
+      def finish   # for backword compatibility
+      end
+    end
+
+
+    class Record
+      # uint8_t  protocol_version;
+      # uint8_t  record_type;
+      # uint16_t request_id;     (big endian)
+      # uint16_t content_length; (big endian)
+      # uint8_t  padding_length;
+      # uint8_t  reserved;
+      HEADER_FORMAT = 'CCnnCC'
+      HEADER_LENGTH = 8
+
+      def self::parse_header(buf)
+        return *buf.unpack(HEADER_FORMAT)
+      end
+
+      def self::class_for(type)
+        RECORD_CLASS[type]
+      end
+
+      def initialize(type, reqid)
+        @type = type
+        @request_id = reqid
+      end
+
+      def version
+        ::FCGI::ProtocolVersion
+      end
+
+      attr_reader :type
+      attr_reader :request_id
+
+      def management_record?
+        @request_id == FCGI_NULL_REQUEST_ID
+      end
+
+      def serialize
+        body = make_body()
+        padlen = body.length % 8
+        header = make_header(body.length, padlen)
+        header + body + "\000" * padlen
+      end
+
+      private
+
+      def make_header(clen, padlen)
+        [version(), @type, @request_id, clen, padlen, 0].pack(HEADER_FORMAT)
+      end
+    end
+
+    class BeginRequestRecord < Record
+      # uint16_t role; (big endian)
+      # uint8_t  flags;
+      # uint8_t  reserved[5];
+      BODY_FORMAT = 'nCC5'
+
+      def BeginRequestRecord.parse(id, body)
+        role, flags, *reserved = *body.unpack(BODY_FORMAT)
+        new(id, role, flags)
+      end
+
+      def initialize(id, role, flags)
+        super FCGI_BEGIN_REQUEST, id
+        @role = role
+        @flags = flags
+      end
+
+      attr_reader :role
+      attr_reader :flags
+      
+      def make_body
+        [@role, @flags, 0, 0, 0, 0, 0].pack(BODY_FORMAT)
+      end
+    end
+
+    class AbortRequestRecord < Record
+      def AbortRequestRecord.parse(id, body)
+        new(id)
+      end
+
+      def initialize(id)
+        super FCGI_ABORT_REQUEST, id
+      end
+    end
+
+    class EndRequestRecord < Record
+      # uint32_t appStatus; (big endian)
+      # uint8_t  protocolStatus;
+      # uint8_t  reserved[3];
+      BODY_FORMAT = 'NCC3'
+
+      def self::parse(id, body)
+        appstatus, protostatus, *reserved = *body.unpack(BODY_FORMAT)
+        new(id, appstatus, protostatus)
+      end
+
+      def initialize(id, appstatus, protostatus)
+        super FCGI_END_REQUEST, id
+        @application_status = appstatus
+        @protocol_status = protostatus
+      end
+
+      attr_reader :application_status
+      attr_reader :protocol_status
+
+      private
+
+      def make_body
+        [@application_status, @protocol_status, 0, 0, 0].pack(BODY_FORMAT)
+      end
+    end
+
+    class UnknownTypeRecord < Record
+      # uint8_t type;
+      # uint8_t reserved[7];
+      BODY_FORMAT = 'CC7'
+
+      def self::parse(id, body)
+        type, *reserved = *body.unpack(BODY_FORMAT)
+        new(id, type)
+      end
+
+      def initialize(id, t)
+        super FCGI_UNKNOWN_TYPE, id
+        @unknown_type = t
+      end
+
+      attr_reader :unknown_type
+
+      private
+
+      def make_body
+        [@unknown_type, 0, 0, 0, 0, 0, 0, 0].pack(BODY_FORMAT)
+      end
+    end
+
+    class ValuesRecord < Record
+      def self::parse(id, body)
+        new(id, parse_values(body))
+      end
+
+      def self::parse_values(buf)
+        result = {}
+        until buf.empty?
+          name, value = *read_pair(buf)
+          result[name] = value
+        end
+        result
+      end
+      
+      def self::read_pair(buf)
+        nlen = read_length(buf)
+        vlen = read_length(buf)
+        return buf.slice!(0, nlen), buf.slice!(0, vlen)
+      end
+      
+      def self::read_length(buf)
+        if buf[0] >> 7 == 0
+        then buf.slice!(0,1)[0]
+        else buf.slice!(0,4).unpack('N')[0] & ((1<<31) - 1)
+        end
+      end
+
+      def initialize(type, id, values)
+        super type, id
+        @values = values
+      end
+
+      attr_reader :values
+
+      private
+
+      def make_body
+        buf = ''
+        @values.each do |name, value|
+          buf << serialize_length(name.length)
+          buf << serialize_length(value.length)
+          buf << name
+          buf << value
+        end
+        buf
+      end
+
+      def serialize_length(len)
+        if len < 0x80
+        then len.chr
+        else [len | (1<<31)].pack('N')
+        end
+      end
+    end
+
+    class GetValuesRecord < ValuesRecord
+      def initialize(id, values)
+        super FCGI_GET_VALUES, id, values
+      end
+    end
+
+    class ParamsRecord < ValuesRecord
+      def initialize(id, values)
+        super FCGI_PARAMS, id, values
+      end
+
+      def empty?
+        @values.empty?
+      end
+    end
+
+    class GenericDataRecord < Record
+      def self::parse(id, body)
+        new(id, body)
+      end
+
+      def initialize(type, id, flagment)
+        super type, id
+        @flagment = flagment
+      end
+
+      attr_reader :flagment
+
+      def empty?
+        @flagment.empty?
+      end
+
+      private
+
+      def make_body
+        @flagment
+      end
+    end
+
+    class StdinDataRecord < GenericDataRecord
+      def initialize(id, flagment)
+        super FCGI_STDIN, id, flagment
+      end
+    end
+
+    class StdoutDataRecord < GenericDataRecord
+      def initialize(id, flagment)
+        super FCGI_STDOUT, id, flagment
+      end
+    end
+
+    class DataRecord < GenericDataRecord
+      def initialize(id, flagment)
+        super FCGI_DATA, id, flagment
+      end
+    end
+
+    class Record   # redefine
+      RECORD_CLASS = {
+        FCGI_GET_VALUES    => GetValuesRecord,
+
+        FCGI_BEGIN_REQUEST => BeginRequestRecord,
+        FCGI_ABORT_REQUEST => AbortRequestRecord,
+        FCGI_PARAMS        => ParamsRecord,
+        FCGI_STDIN         => StdinDataRecord,
+        FCGI_DATA          => DataRecord,
+        FCGI_STDOUT        => StdoutDataRecord,
+        FCGI_END_REQUEST   => EndRequestRecord
+      }
+    end
+
+  end # FCGI class
+

data/lib/cgialt/fcgi.rb

@@ -0,0 +1,28 @@
+##
+## $Rev: 33 $
+## $Release: 0.0.2 $
+## copyright(c) 2007 kuwata-lab.com all rights reserved.
+##
+
+=begin
+
+fcgi.rb 0.8.5 - fcgi.so compatible pure-ruby FastCGI library
+
+fastcgi.rb Copyright (C) 2001 Eli Green
+fcgi.rb    Copyright (C) 2002-2003 MoonWolf <moonwolf@moonwolf.com>
+fcgi.rb    Copyright (C) 2004 Minero Aoki
+
+=end
+
+
+trap('SIGTERM') { exit }
+trap('SIGPIPE', 'IGNORE')
+
+begin
+  raise LoadError if defined?(FCGI_PURE_RUBY) && FCGI_PURE_RUBY
+  require 'fcgi.so'
+rescue LoadError
+  require 'cgialt/fcgi/core'
+end
+
+require 'cgialt/fcgi/cgi_helper' if defined?(CGI)

data/lib/cgialt.rb

@@ -31,7 +31,7 @@
 # protocol.
 
 class CGI
-  RELEASE = ('$Release: 0.0.1 $' =~ /[.\d]+/) && $&
+  RELEASE = ('$Release: 0.0.2 $' =~ /[.\d]+/) && $&
   if $DEBUG || ENV['DEBUG']
     $stderr.puts "*** CGIAlt: release #{RELEASE}"
   end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: cgialt
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
-date: 2007-12-09 00:00:00 +09:00
+  version: 0.0.2
+date: 2007-12-11 00:00:00 +09:00
 summary: an alternative of 'cgi.rb' in pure Ruby
 require_paths: 
 - lib
@@ -32,6 +32,10 @@ files:
 - lib/cgialt
 - lib/cgialt/cookie.rb
 - lib/cgialt/core.rb
+- lib/cgialt/fcgi
+- lib/cgialt/fcgi/cgi_helper.rb
+- lib/cgialt/fcgi/core.rb
+- lib/cgialt/fcgi.rb
 - lib/cgialt/html.rb
 - lib/cgialt/util.rb
 - lib/cgialt.rb
@@ -47,6 +51,7 @@ files:
 - README.txt
 - bench.rb
 - setup.rb
+- CHANGES.txt
 test_files: []
 
 rdoc_options: []