fcgi 0.8.5

data/MANIFEST

@@ -0,0 +1,5 @@
+MANIFEST
+README
+extconf.rb
+fcgi.c
+lib/fcgi.rb

data/README

@@ -0,0 +1,111 @@
+= fcgi - FastCGI library for Ruby
+
+Version 0.8.5
+
+== Depends
+
+=== C version
+  * http://www.fastcgi.com/#TheDevKit
+
+=== Pure Ruby Version
+  * StringIO
+
+== Install
+
+  $ ruby install.rb config
+    (Pure Ruby Version: ruby install.rb config --without-ext)
+    (Some systems need: ruby install.rb config -- --with-fcgi-include=/usr/local/include --with-fcgi-lib=/usr/local/lib)
+  $ ruby install.rb setup
+  # ruby install.rb install
+
+== Usage
+=== Class Method
+--- FCGI.accept
+    Returns FCGI instance
+--- FCGI.each
+
+--- FCGI.each_request
+
+--- FCGI.is_cgi?
+
+--- FCGI.each_cgi
+    Automatically detects whether this program is running under the FastCGI
+    environment, and generates a 'CGI' type object for each request. Also
+    installs signal handlers for graceful handling of SIGPIPE (which may
+    occur if a client gives up on a request before it is complete) and
+    SIGUSR1 (generated by Apache for a 'graceful' exit)
+
+    If you are using the HTML output methods you can also pass the HTML type
+    e.g. FCGI.each_cgi('html3') do ... end
+
+    However, you should beware that the CGI library is quite slow when
+    used in this way, as it dynamically adds a large number of methods
+    to itself each time a new instance is created.
+
+
+=== Instance Method
+--- FCGI#finish
+    Finish
+
+--- FCGI#in
+    Returns Stream or StringIO
+
+--- FCGI#out
+    Returns Stream or StringIO
+
+--- FCGI#err
+    Returns Stream or StringIO
+
+--- FCGI#env
+    Returns Environment(Hash)
+
+== Sample
+Using the FastCGI native interface:
+
+  #!/usr/bin/ruby
+  require "fcgi"
+  
+  FCGI.each {|request|
+    out = request.out
+    out.print "Content-Type: text/plain\r\n"
+    out.print "\r\n"
+    out.print Time.now.to_s
+    request.finish
+  }
+
+Using the CGI-compatible interface, which works both as a standalone CGI
+and under FastCGI with no modifications:
+
+  #!/usr/bin/ruby
+  require "fcgi"
+
+  FCGI.each_cgi {|cgi|
+    name = cgi['name'][0]
+    puts cgi.header
+    puts "You are #{name} " if name
+    puts "Connecting from #{cgi.remote_addr}"
+  }
+
+Note: you can't reference CGI environment variables using ENV when under
+FastCGI. It is recommended that you use the CGI-generated methods, e.g.
+cgi.remote_addr as above.
+
+If you need to access environment variables directly, perhaps extra ones set
+in your Apache config, then use cgi.env_table['REMOTE_ADDR'] instead. This
+isn't quite as portable because env_table is a private method in the
+standard CGI library.
+
+== License
+
+* http://www.ruby-lang.org/ja/LICENSE.txt (Japanese)
+* http://www.ruby-lang.org/en/LICENSE.txt (English)
+
+== Copyright
+
+  fcgi.c     0.1   Copyright (C) 1998-1999  Network Applied Communication Laboratory, Inc.
+             0.8   Copyright (C) 2002 MoonWolf <moonwolf@moonwolf.com>
+
+  fastcgi.rb 0.7   Copyright (C) 2001 Eli Green
+  fcgi.rb    0.8   Copyright (C) 2002 MoonWolf <moonwolf@moonwolf.com>
+  fcgi.rb    0.8.5 Copyright (C) 2004 Minero Aoki
+

data/extconf.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require "mkmf"
+
+dir_config("fcgi")
+
+if have_header("fcgiapp.h") && have_library("fcgi", "FCGX_Accept")
+  create_makefile("fcgi")
+end

data/fcgi.c

@@ -0,0 +1,529 @@
+/*
+ * fcgi.c
+ * Copyright (C) 1998-1999  Network Applied Communication Laboratory, Inc.
+ * Copyright (C) 2002 MoonWolf <moonwolf@moonwolf.com>
+ */
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "ruby.h"
+#include "fcgiapp.h"
+
+static VALUE cFCGI;
+static VALUE eFCGIError;
+static VALUE cFCGIStream;
+static VALUE eFCGIStreamError;
+static VALUE eFCGIStreamUnsupportedVersionError;
+static VALUE eFCGIStreamProtocolError;
+static VALUE eFCGIStreamParamsError;
+static VALUE eFCGIStreamCallSeqError;
+
+typedef struct fcgi_data {
+  FCGX_Request *req;
+  VALUE in;
+  VALUE out;
+  VALUE err;
+  VALUE env;
+} fcgi_data;
+
+static void fcgi_mark(fcgi_data *data)
+{
+/*  rb_gc_mark(data->req); */
+  rb_gc_mark(data->in);
+  rb_gc_mark(data->out);
+  rb_gc_mark(data->err);
+  rb_gc_mark(data->env);
+}
+
+static VALUE fcgi_s_accept(VALUE self)
+{
+  int status;
+  FCGX_Request *req;
+  fd_set readfds;
+  
+  req = ALLOC(FCGX_Request);
+  
+  status = FCGX_InitRequest(req,0,0);
+  if (status != 0) {
+    rb_raise(eFCGIError, "FCGX_Init() failed");
+    return Qnil;
+  }
+
+  FD_ZERO(&readfds);
+  FD_SET(req->listen_sock, &readfds);
+  if (rb_thread_select(req->listen_sock+1, &readfds, NULL, NULL, NULL) < 1) {
+    return Qnil;
+  }
+  
+  status = FCGX_Accept_r(req);
+  if (status >= 0) {
+    fcgi_data *data;
+    char **env;
+    VALUE obj,key, value;
+    char *pkey,*pvalue;
+    
+    obj = Data_Make_Struct(self, fcgi_data, fcgi_mark, 0, data);
+    data->req = req;
+    data->in  = Data_Wrap_Struct(cFCGIStream, 0, 0, req->in);
+    data->out = Data_Wrap_Struct(cFCGIStream, 0, 0, req->out);
+    data->err = Data_Wrap_Struct(cFCGIStream, 0, 0, req->err);
+    data->env = rb_hash_new();
+    env = req->envp;
+    for (env; *env; env++) {
+      int size = 0;
+      pkey = *env;
+      pvalue = pkey;
+      while( *(pvalue++) != '=') size++;
+      key   = rb_str_new(pkey, size);
+      value = rb_str_new2(pvalue);
+      OBJ_TAINT(key);
+      OBJ_TAINT(value);
+      rb_hash_aset(data->env, key, value);
+    }
+    
+    return obj;
+  } else {
+    return Qnil;
+  }
+}
+
+static VALUE fcgi_s_each(VALUE self)
+{
+  VALUE fcgi;
+  
+  while ((fcgi = fcgi_s_accept(self)) != Qnil) {
+    rb_yield(fcgi);
+  }
+  return Qnil;
+}
+
+static VALUE fcgi_s_iscgi(VALUE self)
+{
+  if (FCGX_IsCGI()) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+static VALUE fcgi_in(VALUE self)
+{
+  fcgi_data *data;
+
+  Data_Get_Struct(self, fcgi_data, data);
+  return data->in;
+}
+
+static VALUE fcgi_out(VALUE self)
+{
+  fcgi_data *data;
+
+  Data_Get_Struct(self, fcgi_data, data);
+  return data->out;
+}
+
+static VALUE fcgi_err(VALUE self)
+{
+  fcgi_data *data;
+
+  Data_Get_Struct(self, fcgi_data, data);
+  return data->err;
+}
+
+static VALUE fcgi_env(VALUE self)
+{
+  fcgi_data *data;
+
+  Data_Get_Struct(self, fcgi_data, data);
+  return data->env;
+}
+
+static VALUE fcgi_finish(VALUE self)
+{
+  fcgi_data *data;
+  
+  Data_Get_Struct(self, fcgi_data, data);
+  
+  FCGX_Finish_r(data->req);
+  
+  return Qtrue;
+}
+
+#define CHECK_STREAM_ERROR(stream) {\
+  int err = FCGX_GetError(stream);\
+  if (err) {\
+    if (err > 0) {\
+      rb_sys_fail(0);\
+    }\
+    else {\
+      switch (err) {\
+      case FCGX_UNSUPPORTED_VERSION:\
+        rb_raise(eFCGIStreamUnsupportedVersionError, "unsupported version");\
+        break;\
+      case FCGX_PROTOCOL_ERROR:\
+        rb_raise(eFCGIStreamProtocolError, "protocol error");\
+        break;\
+      case FCGX_PARAMS_ERROR:\
+        rb_raise(eFCGIStreamProtocolError, "parameter error");\
+        break;\
+      case FCGX_CALL_SEQ_ERROR:\
+        rb_raise(eFCGIStreamCallSeqError, "preconditions are not met");\
+        break;\
+      default:\
+        rb_raise(eFCGIStreamError, "unknown error");\
+        break;\
+      }\
+    }\
+  }\
+}
+
+static VALUE fcgi_stream_putc(VALUE self, VALUE ch)
+{
+  FCGX_Stream *stream;
+  int c;
+
+  rb_secure(4);
+  Data_Get_Struct(self, FCGX_Stream, stream);
+  if ((c = FCGX_PutChar(NUM2INT(ch), stream)) == EOF)
+    CHECK_STREAM_ERROR(stream);
+  return INT2NUM(c);
+}
+
+static VALUE fcgi_stream_write(VALUE self, VALUE str)
+{
+  FCGX_Stream *stream;
+  int len;
+
+  rb_secure(4);
+  Data_Get_Struct(self, FCGX_Stream, stream);
+  str = rb_obj_as_string(str);
+  len = FCGX_PutStr(RSTRING(str)->ptr, RSTRING(str)->len, stream);
+  if (len == EOF) CHECK_STREAM_ERROR(stream);
+  return INT2NUM(len);
+}
+
+static VALUE fcgi_stream_print(int argc, VALUE *argv, VALUE out)
+{
+  int i;
+  VALUE line;
+
+  /* if no argument given, print `$_' */
+  if (argc == 0) {
+    argc = 1;
+    line = rb_lastline_get();
+    argv = &line;
+  }
+  for (i=0; i<argc; i++) {
+    if (!NIL_P(rb_output_fs) && i>0) {
+      fcgi_stream_write(out, rb_output_fs);
+    }
+    switch (TYPE(argv[i])) {
+    case T_NIL:
+      fcgi_stream_write(out, rb_str_new2("nil"));
+      break;
+    default:
+      fcgi_stream_write(out, argv[i]);
+      break;
+    }
+  }
+  if (!NIL_P(rb_output_rs)) {
+    fcgi_stream_write(out, rb_output_rs);
+  }
+
+  return Qnil;
+}
+
+static VALUE fcgi_stream_printf(int argc, VALUE *argv, VALUE out)
+{
+  fcgi_stream_write(out, rb_f_sprintf(argc, argv));
+  return Qnil;
+}
+
+static VALUE fcgi_stream_puts _((int, VALUE*, VALUE));
+
+static VALUE fcgi_stream_puts_ary(VALUE ary, VALUE out)
+{
+  VALUE tmp;
+  int i;
+
+  for (i=0; i<RARRAY(ary)->len; i++) {
+    tmp = RARRAY(ary)->ptr[i];
+    if (rb_inspecting_p(tmp)) {
+      tmp = rb_str_new2("[...]");
+    }
+    fcgi_stream_puts(1, &tmp, out);
+  }
+  return Qnil;
+}
+
+static VALUE fcgi_stream_puts(int argc, VALUE *argv, VALUE out)
+{
+  int i;
+  VALUE line;
+
+  /* if no argument given, print newline. */
+  if (argc == 0) {
+    fcgi_stream_write(out, rb_default_rs);
+    return Qnil;
+  }
+  for (i=0; i<argc; i++) {
+    switch (TYPE(argv[i])) {
+    case T_NIL:
+      line = rb_str_new2("nil");
+      break;
+    case T_ARRAY:
+      rb_protect_inspect(fcgi_stream_puts_ary, argv[i], out);
+      continue;
+    default:
+      line = argv[i];
+      break;
+    }
+    line = rb_obj_as_string(line);
+    fcgi_stream_write(out, line);
+    if (RSTRING(line)->ptr[RSTRING(line)->len-1] != '\n') {
+      fcgi_stream_write(out, rb_default_rs);
+    }
+  }
+
+  return Qnil;
+}
+
+static VALUE fcgi_stream_addstr(VALUE out, VALUE str)
+{
+  fcgi_stream_write(out, str);
+  return out;
+}
+
+static VALUE fcgi_stream_flush(VALUE self)
+{
+  FCGX_Stream *stream;
+
+  Data_Get_Struct(self, FCGX_Stream, stream);
+  if (FCGX_FFlush(stream) == EOF)
+    CHECK_STREAM_ERROR(stream);
+  return Qnil;
+}
+
+static VALUE fcgi_stream_getc(VALUE self)
+{
+  FCGX_Stream *stream;
+  int c;
+
+  Data_Get_Struct(self, FCGX_Stream, stream);
+  if ((c = FCGX_GetChar(stream)) == EOF) {
+    CHECK_STREAM_ERROR(stream);
+    return Qnil;
+  }
+  else {
+    return INT2NUM(c);
+  }
+}
+
+static VALUE fcgi_stream_ungetc(VALUE self, VALUE ch)
+{
+  FCGX_Stream *stream;
+  int c;
+
+  if (rb_safe_level() >= 4 && !OBJ_TAINTED(self)) {
+    rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
+  }
+  Data_Get_Struct(self, FCGX_Stream, stream);
+  c = FCGX_UnGetChar(NUM2INT(ch), stream);
+  CHECK_STREAM_ERROR(stream);
+  return INT2NUM(c);
+}
+
+static VALUE fcgi_stream_gets(VALUE self)
+{
+  FCGX_Stream *stream;
+  char buff[BUFSIZ];
+  VALUE str = rb_str_new("", 0);
+  OBJ_TAINT(str);
+
+  if (rb_safe_level() >= 4 && !OBJ_TAINTED(self)) {
+    rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
+  }
+
+  Data_Get_Struct(self, FCGX_Stream, stream);
+
+  for (;;) {
+    if (FCGX_GetLine(buff, BUFSIZ, stream) == NULL) {
+      CHECK_STREAM_ERROR(stream);
+      break;
+    }
+    rb_str_cat(str, buff, strlen(buff));
+    if (strchr(buff, '\n')) break;
+  }
+  if (RSTRING(str)->len > 0)
+    return str;
+  else
+    return Qnil;
+}
+
+static VALUE fcgi_stream_read(int argc, VALUE *argv, VALUE self)
+{
+  VALUE num,str;
+  FCGX_Stream *stream;
+  char *buff;
+  int n;
+
+  if (rb_safe_level() >= 4 && !OBJ_TAINTED(self)) {
+    rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
+  }
+
+  Data_Get_Struct(self, FCGX_Stream, stream);
+
+  if (argc==0) {
+    buff = ALLOC_N(char, 16384);
+    n = FCGX_GetStr(buff, 16384, stream);
+    CHECK_STREAM_ERROR(stream);
+    if (n == 0) return Qnil;
+    str = rb_str_new(buff, n);
+    OBJ_TAINT(str);
+    
+    while(!FCGX_HasSeenEOF(stream)) {
+      n = FCGX_GetStr(buff, 16384, stream);
+      CHECK_STREAM_ERROR(stream);
+      if (n > 0) {
+        rb_str_cat(str, buff, n);
+      } else {
+        return Qnil;
+      }
+    }
+    return str;
+  }
+
+  num = argv[0];
+  n = NUM2INT(num);
+
+  buff = ALLOC_N(char, n);
+  n = FCGX_GetStr(buff, n, stream);
+  CHECK_STREAM_ERROR(stream);
+  if (n > 0) {
+    str = rb_str_new(buff, n);
+    OBJ_TAINT(str);
+    return str;
+  }
+  else {
+    return Qnil;
+  }
+}
+
+static VALUE fcgi_stream_eof(VALUE self)
+{
+  FCGX_Stream *stream;
+
+  if (rb_safe_level() >= 4 && !OBJ_TAINTED(self)) {
+    rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
+  }
+  Data_Get_Struct(self, FCGX_Stream, stream);
+  return FCGX_HasSeenEOF(stream) ? Qtrue : Qfalse;
+}
+
+static VALUE fcgi_stream_close(VALUE self)
+{
+  FCGX_Stream *stream;
+
+  if (rb_safe_level() >= 4 && !OBJ_TAINTED(self)) {
+    rb_raise(rb_eSecurityError, "Insecure: can't close");
+  }
+  Data_Get_Struct(self, FCGX_Stream, stream);
+  if (FCGX_FClose(stream) == EOF)
+    CHECK_STREAM_ERROR(stream);
+  return Qnil;
+}
+
+static VALUE fcgi_stream_closed(VALUE self)
+{
+  FCGX_Stream *stream;
+
+  Data_Get_Struct(self, FCGX_Stream, stream);
+  return stream->isClosed ? Qtrue : Qfalse;
+}
+
+static VALUE fcgi_stream_binmode(VALUE self)
+{
+  if (rb_safe_level() >= 4 && !OBJ_TAINTED(self)) {
+    rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
+  }
+  return self;
+}
+
+static VALUE fcgi_stream_isatty(VALUE self)
+{
+  if (rb_safe_level() >= 4 && !OBJ_TAINTED(self)) {
+    rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
+  }
+  return Qfalse;
+}
+
+static VALUE fcgi_stream_sync(VALUE self)
+{
+  if (rb_safe_level() >= 4 && !OBJ_TAINTED(self)) {
+    rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
+  }
+  return Qfalse;
+}
+
+static VALUE fcgi_stream_setsync(VALUE self,VALUE sync)
+{
+  if (rb_safe_level() >= 4 && !OBJ_TAINTED(self)) {
+    rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
+  }
+  return Qfalse;
+}
+
+
+
+void Init_fcgi()
+{
+  
+  FCGX_Init();
+  
+  cFCGI = rb_define_class("FCGI", rb_cObject);
+  eFCGIError =rb_define_class_under(cFCGI, "Error", rb_eStandardError);
+  rb_define_singleton_method(cFCGI, "accept", fcgi_s_accept, 0);
+  rb_define_singleton_method(cFCGI, "each", fcgi_s_each, 0);
+  rb_define_singleton_method(cFCGI, "each_request", fcgi_s_each, 0);
+  rb_define_singleton_method(cFCGI, "is_cgi?", fcgi_s_iscgi, 0);
+  rb_define_method(cFCGI, "in", fcgi_in, 0);
+  rb_define_method(cFCGI, "out", fcgi_out, 0);
+  rb_define_method(cFCGI, "err", fcgi_err, 0);
+  rb_define_method(cFCGI, "env", fcgi_env, 0);
+  rb_define_method(cFCGI, "finish", fcgi_finish, 0);
+  
+  cFCGIStream = rb_define_class_under(cFCGI, "Stream", rb_cObject);
+  eFCGIStreamError =rb_define_class_under(cFCGIStream, "Error", rb_eStandardError);
+  eFCGIStreamUnsupportedVersionError =
+    rb_define_class_under(cFCGIStream, "UnsupportedVersionError",
+                          eFCGIStreamError);
+  eFCGIStreamProtocolError = rb_define_class_under(cFCGIStream, "ProtocolError",
+                                                   eFCGIStreamError);
+  eFCGIStreamParamsError = rb_define_class_under(cFCGIStream, "ParamsError",
+                                                 eFCGIStreamError);
+  eFCGIStreamCallSeqError = rb_define_class_under(cFCGIStream, "CallSeqError",
+                                                  eFCGIStreamError);
+  rb_undef_method(CLASS_OF(cFCGIStream), "new");
+  rb_define_method(cFCGIStream, "putc", fcgi_stream_putc, 1);
+  rb_define_method(cFCGIStream, "write", fcgi_stream_write, 1);
+  rb_define_method(cFCGIStream, "print", fcgi_stream_print, -1);
+  rb_define_method(cFCGIStream, "printf", fcgi_stream_printf, -1);
+  rb_define_method(cFCGIStream, "puts", fcgi_stream_puts, -1);
+  rb_define_method(cFCGIStream, "<<", fcgi_stream_addstr, 1);
+  rb_define_method(cFCGIStream, "flush", fcgi_stream_flush, 0);
+  rb_define_method(cFCGIStream, "getc", fcgi_stream_getc, 0);
+  rb_define_method(cFCGIStream, "ungetc", fcgi_stream_ungetc, 1);
+  rb_define_method(cFCGIStream, "gets", fcgi_stream_gets, 0);
+  rb_define_method(cFCGIStream, "read", fcgi_stream_read, -1);
+  rb_define_method(cFCGIStream, "eof", fcgi_stream_eof, 0);
+  rb_define_method(cFCGIStream, "eof?", fcgi_stream_eof, 0);
+  rb_define_method(cFCGIStream, "close", fcgi_stream_close, 0);
+  rb_define_method(cFCGIStream, "closed?", fcgi_stream_closed, 0);
+  rb_define_method(cFCGIStream, "binmode", fcgi_stream_binmode, 0);
+  rb_define_method(cFCGIStream, "isatty", fcgi_stream_isatty, 0);
+  rb_define_method(cFCGIStream, "tty?", fcgi_stream_isatty, 0);
+  rb_define_method(cFCGIStream, "sync", fcgi_stream_sync, 0);
+  rb_define_method(cFCGIStream, "sync=", fcgi_stream_setsync, 1);
+}

data/fcgi.gemspec

@@ -0,0 +1,16 @@
+Gem::Specification.new do |s|
+  s.name = %q{fcgi}
+  s.version = "0.8.5"
+  s.date = Time.now 
+  s.require_path = %q{.}
+  s.summary = %q{FastCGI ruby binding.}
+  s.author = %q{Network Applied Communication Laboratory, Inc., MoonWolf, Eli Green, Minero Aoki}
+  s.platform = Gem::Platform::RUBY
+  s.files = Dir.glob('**/*')
+  s.email = %q{moonwolf@moonwolf.com}
+  s.homepage = %q{http://rwiki.moonwolf.com/rw-cgi.cgi?cmd=view;name=fcgi}
+  s.autorequire = %q{fcgi}
+  s.extensions = ["extconf.rb"]
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README"]
+end

data/lib/fcgi.rb

@@ -0,0 +1,606 @@
+=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 '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
+    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 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
+      }
+    end
+
+  end # FCGI class
+end # begin
+
+# 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

metadata

@@ -0,0 +1,44 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: "0.8"
+specification_version: 1
+name: fcgi
+version: !ruby/object:Gem::Version 
+  version: 0.8.5
+date: 2004-10-21
+summary: FastCGI ruby binding.
+require_paths: 
+  - "."
+author: "Network Applied Communication Laboratory, Inc., MoonWolf, Eli Green, Minero Aoki"
+email: moonwolf@moonwolf.com
+homepage: http://rwiki.moonwolf.com/rw-cgi.cgi?cmd=view;name=fcgi
+rubyforge_project: 
+description: 
+autorequire: fcgi
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+files: 
+  - lib
+  - extconf.rb
+  - fcgi.c
+  - MANIFEST
+  - README
+  - fcgi.gemspec
+  - lib/fcgi.rb
+test_files: []
+rdoc_options: []
+extra_rdoc_files: 
+  - README
+executables: []
+extensions: 
+  - extconf.rb
+requirements: []
+dependencies: []