fcgi 0.8.5 → 0.9.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bb36e2d30016bac819a6aec9d30890bcca7750ec82862e099f89ae341049ed7c
+  data.tar.gz: af9e34e45aa8cb7673f721439e765e82e31ed8fd910987d294801335ce17fa0d
+SHA512:
+  metadata.gz: 79f085764709841d49d4c6e91fc8188a5ba952a7e11f544addde2602d7a8e325bc346613d6c12bf3ade8cb09e0269d79c28a49a71ed369ef833542c3da2ff736
+  data.tar.gz: 0c02df774067bab5dcc11f065bee1f55e941900f5602ce60deceef24df78c1588cbefd1cae67926d3335c4e1aa1e360c25ffc3c2daeffe19e973ee5f9b98d912

data/LICENSE

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

data/{README → README.rdoc}

@@ -1,22 +1,18 @@
-= fcgi - FastCGI library for Ruby
+= fcgi - The New generation of FastCGI library for Ruby.
 
-Version 0.8.5
+Version 0.9.2.1
 
 == Depends
 
 === C version
-  * http://www.fastcgi.com/#TheDevKit
+  * ((<libfcgi|URL:http://www.fastcgi.com/#TheDevKit>))(FastCGI Developer's Kit)
 
 === 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
+  $ gem install fcgi
 
 == Usage
 === Class Method
@@ -42,7 +38,6 @@ Version 0.8.5
     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
@@ -60,11 +55,12 @@ Version 0.8.5
     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"
@@ -97,13 +93,14 @@ standard CGI library.
 
 == License
 
-* http://www.ruby-lang.org/ja/LICENSE.txt (Japanese)
-* http://www.ruby-lang.org/en/LICENSE.txt (English)
+* ((<URL:http://www.ruby-lang.org/ja/LICENSE.txt>)) (Japanese)
+* ((<URL: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>
+             0.9   Copyright (C) 2013 mva <mva@mva.name> Alpha, LLC
 
   fastcgi.rb 0.7   Copyright (C) 2001 Eli Green
   fcgi.rb    0.8   Copyright (C) 2002 MoonWolf <moonwolf@moonwolf.com>

data/README.signals

@@ -0,0 +1,76 @@
+= Handling of SIGUSR1
+
+When you request a 'graceful' restart of Apache, mod_fastcgi sends a SIGUSR1
+to each of the fastcgi worker processes. The intention is that each one
+should finish the current request, and then exit, at which point Apache will
+restart it. Of course, if the worker isn't doing anything, it should die
+immediately.
+
+This is implemented in the fcgi C library as follows:
+
+- a signal handler is installed for SIGUSR1, which just sets a flag
+  (shutdownPending) and returns
+- fcgi sits inside an accept() call waiting for a new request
+- if this accept() call terminates with EINTR, and this flag is set, then
+  it returns with no request
+
+Unfortunately, Ruby defeats this mechanism in at least two ways:
+
+1. Ruby installs its own signal handlers for a host of common signals,
+including USR1. The fcgi library will not install its own handler if it
+detects that a handler has already been set (i.e. the current handler is not
+SIG_DFL)
+
+2. When Ruby installs its own signal handlers, it does so with SA_RESTART
+set. This means that the accept() call does not terminate with EINTR; it is
+restarted automatically by the OS.
+
+When a signal comes in during the accept(), Ruby's own handler does nothing
+except store it in a queue to be processed later. It is only when the
+accept() call completes, i.e. when a genuine new request comes in, that Ruby
+takes action. Unfortunately it's too late by then, and if that
+already-accepted request is not honoured, a 500 Internal Error will be
+returned to the client.
+
+The simplest solution to this would be to remove Ruby's SIGUSR1 handler
+before initialising the FastCGI library.
+
+However, a cleaner solution is to call rb_thread_select before going into
+FastCGI's accept loop. If a signal happens during the select, it can be
+handled using Ruby's normal mechanisms. This also gives a very useful
+side-benefit, which is that FCGI::accept no longer blocks out other Ruby
+threads. The program below demonstrates this problem; its background logging
+thread is supposed to write a message every 10 seconds, but under older
+versions of ruby-fcgi it does not do so if it is waiting for a new request.
+
+  #!/usr/local/bin/ruby
+  require "fcgi"
+
+  Thread.new do
+    f = File.new("/tmp/fcgi.log","a")
+    f.sync=true
+    while true
+      f.puts "#{Time.now.to_s} pid #{$$}"
+      sleep 10
+    end
+  end
+
+  FCGI.each_cgi {|cgi|
+    name = cgi['name'][0]
+    puts cgi.header
+    puts "Hey! You are #{name} " if name
+    puts "Connecting from #{cgi.remote_addr}"
+  }
+
+Having protected the accept() with a ruby select(), you can then handle
+signals as follows:
+
+- call FCGI::accept  (it will raise an exception if USR1 is called)
+- install a USR1 handler
+- process the request
+- remove the USR1 handler
+
+The USR1 handler should set a flag to note if a USR1 signal came in while
+the request was being processed; you terminate the loop if it was set. The
+overall effect is that USR1 will cause the process to terminate, but without
+causing a half-completed request.

data/VERSION

@@ -0,0 +1 @@
+0.9.2.1

data/{MANIFEST → ext/fcgi/MANIFEST}

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

data/ext/fcgi/Makefile

@@ -0,0 +1 @@
+# Use ruby extconf.rb to generate makefile

data/ext/fcgi/extconf.rb

@@ -0,0 +1,7 @@
+require "mkmf"
+
+dir_config("fcgi")
+
+if (have_header("fcgiapp.h") || have_header("fastcgi/fcgiapp.h")) && have_library("fcgi", "FCGX_Accept")
+  create_makefile("fcgi")
+end

data/{fcgi.c → ext/fcgi/fcgi.c}

@@ -1,15 +1,34 @@
 /*
  * fcgi.c
  * Copyright (C) 1998-1999  Network Applied Communication Laboratory, Inc.
- * Copyright (C) 2002 MoonWolf <moonwolf@moonwolf.com>
+ * Copyright (C) 2002-2006  MoonWolf <moonwolf@moonwolf.com>
+ * Copyright (C) 2012-2014  mva <mva@mva.name>
  */
 
 #include <stdio.h>
 #include <sys/types.h>
 #include <unistd.h>
+#include <errno.h>
+#include <fcntl.h>
 
 #include "ruby.h"
+#ifdef HAVE_RUBY_VERSION_H
+#include "ruby/version.h"
+#endif
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(str) (RSTRING(str)->ptr)
+#endif
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(str) (RSTRING(str)->len)
+#endif
+
+#ifdef HAVE_FASTCGI_FCGIAPP_H
+#include <fastcgi/fcgiapp.h>
+#else
 #include "fcgiapp.h"
+#endif
+
 
 static VALUE cFCGI;
 static VALUE eFCGIError;
@@ -20,6 +39,11 @@ static VALUE eFCGIStreamProtocolError;
 static VALUE eFCGIStreamParamsError;
 static VALUE eFCGIStreamCallSeqError;
 
+typedef struct fcgi_stream_data {
+  VALUE req;
+  FCGX_Stream *stream;
+} fcgi_stream_data;
+
 typedef struct fcgi_data {
   FCGX_Request *req;
   VALUE in;
@@ -28,50 +52,82 @@ typedef struct fcgi_data {
   VALUE env;
 } fcgi_data;
 
+static void fcgi_stream_mark(fcgi_stream_data *stream_data)
+{
+  rb_gc_mark(stream_data->req);
+}
+
+static void fcgi_stream_free(fcgi_stream_data *stream_data)
+{
+  free(stream_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 void fcgi_free_req(fcgi_data *data)
+{
+  FCGX_Free(data->req, 1);
+  free(data->req);
+  free(data);
+}
+
 static VALUE fcgi_s_accept(VALUE self)
 {
   int status;
   FCGX_Request *req;
-  fd_set readfds;
-  
+  rb_fdset_t 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) {
+  rb_fd_init(&readfds);
+  rb_fd_set(req->listen_sock, &readfds);
+  if (rb_thread_fd_select(readfds.maxfd, &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);
+    fcgi_stream_data *stream_data;
+    char      **env;
+    VALUE     obj,key, value;
+    char      *pkey,*pvalue;
+    int       flags, fd;
+
+    /* Unset NONBLOCKING */
+    fd = ((FCGX_Request*) req)->ipcFd;
+    flags = fcntl(fd, F_GETFL);
+
+    if (flags & O_NONBLOCK) {
+       fcntl(fd, F_SETFL, flags & ~O_NONBLOCK);
+    }
+
+    obj = Data_Make_Struct(self, fcgi_data, fcgi_mark, fcgi_free_req, 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->in = Data_Make_Struct(cFCGIStream, fcgi_stream_data, fcgi_stream_mark, fcgi_stream_free, stream_data);
+    stream_data->stream = req->in;
+    stream_data->req = obj;
+    data->out = Data_Make_Struct(cFCGIStream, fcgi_stream_data, fcgi_stream_mark, fcgi_stream_free, stream_data);
+    stream_data->stream = req->out;
+    stream_data->req = obj;
+    data->err = Data_Make_Struct(cFCGIStream, fcgi_stream_data, fcgi_stream_mark, fcgi_stream_free, stream_data);
+    stream_data->stream = req->err;
+    stream_data->req = obj;
     data->env = rb_hash_new();
     env = req->envp;
-    for (env; *env; env++) {
+    for (; *env; env++) {
       int size = 0;
       pkey = *env;
       pvalue = pkey;
@@ -82,9 +138,11 @@ static VALUE fcgi_s_accept(VALUE self)
       OBJ_TAINT(value);
       rb_hash_aset(data->env, key, value);
     }
-    
+
     return obj;
   } else {
+    FCGX_Free(req, 1);
+    free(req);
     return Qnil;
   }
 }
@@ -92,7 +150,7 @@ static VALUE fcgi_s_accept(VALUE self)
 static VALUE fcgi_s_each(VALUE self)
 {
   VALUE fcgi;
-  
+
   while ((fcgi = fcgi_s_accept(self)) != Qnil) {
     rb_yield(fcgi);
   }
@@ -143,19 +201,35 @@ static VALUE fcgi_env(VALUE self)
 static VALUE fcgi_finish(VALUE self)
 {
   fcgi_data *data;
-  
+  fcgi_stream_data *stream_data;
+
   Data_Get_Struct(self, fcgi_data, data);
-  
+
+  if (Qnil != data->in) {
+    Data_Get_Struct(data->in, fcgi_stream_data, stream_data);
+    stream_data->req = Qnil; stream_data->stream = NULL;
+  }
+  if (Qnil != data->out) {
+    Data_Get_Struct(data->out, fcgi_stream_data, stream_data);
+    stream_data->req = Qnil; stream_data->stream = NULL;
+  }
+  if (Qnil != data->err) {
+    Data_Get_Struct(data->err, fcgi_stream_data, stream_data);
+    stream_data->req = Qnil; stream_data->stream = NULL;
+  }
+
+  data->in = data->out = data->err = Qnil;
   FCGX_Finish_r(data->req);
-  
+
   return Qtrue;
 }
 
 #define CHECK_STREAM_ERROR(stream) {\
   int err = FCGX_GetError(stream);\
+	extern int errno; \
   if (err) {\
     if (err > 0) {\
-      rb_sys_fail(0);\
+      rb_raise(eFCGIStreamError, "unknown error (syscall error)");\
     }\
     else {\
       switch (err) {\
@@ -179,13 +253,22 @@ static VALUE fcgi_finish(VALUE self)
   }\
 }
 
+#define Data_Get_Stream(value, stream) do {\
+    fcgi_stream_data* _fsd;\
+    Data_Get_Struct(value, fcgi_stream_data, _fsd);\
+    if (NULL == (stream = _fsd->stream))\
+      rb_raise(eFCGIStreamError, "stream invalid as fastcgi request is already finished");\
+  } while (0)
+
 static VALUE fcgi_stream_putc(VALUE self, VALUE ch)
 {
   FCGX_Stream *stream;
   int c;
 
+#if !defined(RUBY_API_VERSION_MAJOR) || (RUBY_API_VERSION_MAJOR < 3)
   rb_secure(4);
-  Data_Get_Struct(self, FCGX_Stream, stream);
+#endif
+  Data_Get_Stream(self, stream);
   if ((c = FCGX_PutChar(NUM2INT(ch), stream)) == EOF)
     CHECK_STREAM_ERROR(stream);
   return INT2NUM(c);
@@ -196,10 +279,12 @@ static VALUE fcgi_stream_write(VALUE self, VALUE str)
   FCGX_Stream *stream;
   int len;
 
+#if !defined(RUBY_API_VERSION_MAJOR) || (RUBY_API_VERSION_MAJOR < 3)
   rb_secure(4);
-  Data_Get_Struct(self, FCGX_Stream, stream);
+#endif
+  Data_Get_Stream(self, stream);
   str = rb_obj_as_string(str);
-  len = FCGX_PutStr(RSTRING(str)->ptr, RSTRING(str)->len, stream);
+  len = FCGX_PutStr(RSTRING_PTR(str), RSTRING_LEN(str), stream);
   if (len == EOF) CHECK_STREAM_ERROR(stream);
   return INT2NUM(len);
 }
@@ -243,16 +328,19 @@ static VALUE fcgi_stream_printf(int argc, VALUE *argv, VALUE out)
 
 static VALUE fcgi_stream_puts _((int, VALUE*, VALUE));
 
-static VALUE fcgi_stream_puts_ary(VALUE ary, VALUE out)
+static VALUE fcgi_stream_puts_ary(VALUE ary, VALUE out, int recur)
 {
   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("[...]");
-    }
+  if (recur) {
+    tmp = rb_str_new2("[...]");
+    fcgi_stream_puts(1, &tmp, out);
+    return Qnil;
+  }
+
+  for (i=0; i<RARRAY_LEN(ary); i++) {
+    tmp = RARRAY_PTR(ary)[i];
     fcgi_stream_puts(1, &tmp, out);
   }
   return Qnil;
@@ -274,7 +362,7 @@ static VALUE fcgi_stream_puts(int argc, VALUE *argv, VALUE out)
       line = rb_str_new2("nil");
       break;
     case T_ARRAY:
-      rb_protect_inspect(fcgi_stream_puts_ary, argv[i], out);
+      rb_exec_recursive(fcgi_stream_puts_ary, argv[i], out);
       continue;
     default:
       line = argv[i];
@@ -282,7 +370,7 @@ static VALUE fcgi_stream_puts(int argc, VALUE *argv, VALUE out)
     }
     line = rb_obj_as_string(line);
     fcgi_stream_write(out, line);
-    if (RSTRING(line)->ptr[RSTRING(line)->len-1] != '\n') {
+    if (RSTRING_PTR(line)[RSTRING_LEN(line)-1] != '\n') {
       fcgi_stream_write(out, rb_default_rs);
     }
   }
@@ -300,7 +388,7 @@ static VALUE fcgi_stream_flush(VALUE self)
 {
   FCGX_Stream *stream;
 
-  Data_Get_Struct(self, FCGX_Stream, stream);
+  Data_Get_Stream(self, stream);
   if (FCGX_FFlush(stream) == EOF)
     CHECK_STREAM_ERROR(stream);
   return Qnil;
@@ -311,7 +399,7 @@ static VALUE fcgi_stream_getc(VALUE self)
   FCGX_Stream *stream;
   int c;
 
-  Data_Get_Struct(self, FCGX_Stream, stream);
+  Data_Get_Stream(self, stream);
   if ((c = FCGX_GetChar(stream)) == EOF) {
     CHECK_STREAM_ERROR(stream);
     return Qnil;
@@ -326,27 +414,30 @@ static VALUE fcgi_stream_ungetc(VALUE self, VALUE ch)
   FCGX_Stream *stream;
   int c;
 
+#if !defined(RUBY_API_VERSION_MAJOR) || (RUBY_API_VERSION_MAJOR < 3)
   if (rb_safe_level() >= 4 && !OBJ_TAINTED(self)) {
     rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
   }
-  Data_Get_Struct(self, FCGX_Stream, stream);
+#endif
+  Data_Get_Stream(self, stream);
   c = FCGX_UnGetChar(NUM2INT(ch), stream);
   CHECK_STREAM_ERROR(stream);
   return INT2NUM(c);
 }
 
-static VALUE fcgi_stream_gets(VALUE self)
-{
+static VALUE fcgi_stream_gets(VALUE self) {
   FCGX_Stream *stream;
   char buff[BUFSIZ];
-  VALUE str = rb_str_new("", 0);
+  VALUE str = rb_str_new(0,0);
   OBJ_TAINT(str);
 
+#if !defined(RUBY_API_VERSION_MAJOR) || (RUBY_API_VERSION_MAJOR < 3)
   if (rb_safe_level() >= 4 && !OBJ_TAINTED(self)) {
     rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
   }
+#endif
 
-  Data_Get_Struct(self, FCGX_Stream, stream);
+  Data_Get_Stream(self, stream);
 
   for (;;) {
     if (FCGX_GetLine(buff, BUFSIZ, stream) == NULL) {
@@ -356,7 +447,7 @@ static VALUE fcgi_stream_gets(VALUE self)
     rb_str_cat(str, buff, strlen(buff));
     if (strchr(buff, '\n')) break;
   }
-  if (RSTRING(str)->len > 0)
+  if (RSTRING_LEN(str) > 0)
     return str;
   else
     return Qnil;
@@ -369,29 +460,36 @@ static VALUE fcgi_stream_read(int argc, VALUE *argv, VALUE self)
   char *buff;
   int n;
 
+#if !defined(RUBY_API_VERSION_MAJOR) || (RUBY_API_VERSION_MAJOR < 3)
   if (rb_safe_level() >= 4 && !OBJ_TAINTED(self)) {
     rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
   }
+#endif
 
-  Data_Get_Struct(self, FCGX_Stream, stream);
+  Data_Get_Stream(self, stream);
 
   if (argc==0) {
     buff = ALLOC_N(char, 16384);
     n = FCGX_GetStr(buff, 16384, stream);
     CHECK_STREAM_ERROR(stream);
-    if (n == 0) return Qnil;
+    if (n == 0) {
+      free(buff);
+      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 {
+        free(buff);
         return Qnil;
       }
     }
+    free(buff);
     return str;
   }
 
@@ -404,9 +502,11 @@ static VALUE fcgi_stream_read(int argc, VALUE *argv, VALUE self)
   if (n > 0) {
     str = rb_str_new(buff, n);
     OBJ_TAINT(str);
+    free(buff);
     return str;
   }
   else {
+    free(buff);
     return Qnil;
   }
 }
@@ -415,10 +515,12 @@ static VALUE fcgi_stream_eof(VALUE self)
 {
   FCGX_Stream *stream;
 
+#if !defined(RUBY_API_VERSION_MAJOR) || (RUBY_API_VERSION_MAJOR < 3)
   if (rb_safe_level() >= 4 && !OBJ_TAINTED(self)) {
     rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
   }
-  Data_Get_Struct(self, FCGX_Stream, stream);
+#endif
+  Data_Get_Stream(self, stream);
   return FCGX_HasSeenEOF(stream) ? Qtrue : Qfalse;
 }
 
@@ -426,10 +528,12 @@ static VALUE fcgi_stream_close(VALUE self)
 {
   FCGX_Stream *stream;
 
+#if !defined(RUBY_API_VERSION_MAJOR) || (RUBY_API_VERSION_MAJOR < 3)
   if (rb_safe_level() >= 4 && !OBJ_TAINTED(self)) {
     rb_raise(rb_eSecurityError, "Insecure: can't close");
   }
-  Data_Get_Struct(self, FCGX_Stream, stream);
+#endif
+  Data_Get_Stream(self, stream);
   if (FCGX_FClose(stream) == EOF)
     CHECK_STREAM_ERROR(stream);
   return Qnil;
@@ -439,61 +543,68 @@ static VALUE fcgi_stream_closed(VALUE self)
 {
   FCGX_Stream *stream;
 
-  Data_Get_Struct(self, FCGX_Stream, stream);
+  Data_Get_Stream(self, stream);
   return stream->isClosed ? Qtrue : Qfalse;
 }
 
 static VALUE fcgi_stream_binmode(VALUE self)
 {
+#if !defined(RUBY_API_VERSION_MAJOR) || (RUBY_API_VERSION_MAJOR < 3)
   if (rb_safe_level() >= 4 && !OBJ_TAINTED(self)) {
     rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
   }
+#endif
   return self;
 }
 
 static VALUE fcgi_stream_isatty(VALUE self)
 {
+#if !defined(RUBY_API_VERSION_MAJOR) || (RUBY_API_VERSION_MAJOR < 3)
   if (rb_safe_level() >= 4 && !OBJ_TAINTED(self)) {
     rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
   }
+#endif
   return Qfalse;
 }
 
 static VALUE fcgi_stream_sync(VALUE self)
 {
+#if !defined(RUBY_API_VERSION_MAJOR) || (RUBY_API_VERSION_MAJOR < 3)
   if (rb_safe_level() >= 4 && !OBJ_TAINTED(self)) {
     rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
   }
+#endif
   return Qfalse;
 }
 
 static VALUE fcgi_stream_setsync(VALUE self,VALUE sync)
 {
+#if !defined(RUBY_API_VERSION_MAJOR) || (RUBY_API_VERSION_MAJOR < 3)
   if (rb_safe_level() >= 4 && !OBJ_TAINTED(self)) {
     rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
   }
+#endif
   return Qfalse;
 }
 
 
 
-void Init_fcgi()
-{
-  
+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, "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 =

data/fcgi.gemspec

@@ -1,16 +1,34 @@
 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"]
+  s.version = "0.9.2.2"
+  s.license = "MIT"
+
+  s.authors = [%q{mva}]
+  s.date = %q{2022-10-17}
+  s.description = %q{FastCGI is a language independent, scalable, open extension to CGI that provides high performance without the limitations of server specific APIs. This version aims to be compatible with both 1.8.x and 1.9.x versions of Ruby, and also will be ported to 2.0.x. It has been hacked to work with Ruby 3.0.x.}
+  s.email = %q{mva@mva.name}
+  s.extensions = [%q{ext/fcgi/extconf.rb}]
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.rdoc",
+    "README.signals"
+  ]
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.files = [
+    "VERSION",
+    "ext/fcgi/MANIFEST",
+    "ext/fcgi/Makefile",
+    "ext/fcgi/extconf.rb",
+    "ext/fcgi/fcgi.c",
+    "lib/fcgi.rb",
+    "fcgi.gemspec"
+  ]
+  s.test_files = [
+    "test/helper.rb",
+    "test/test_fcgi.rb"
+  ]
+  s.homepage = %q{http://github.com/alphallc/ruby-fcgi-ng}
+  s.require_paths = [%q{lib}]
+  s.summary = %q{FastCGI library for Ruby.}
 end
+

data/lib/fcgi.rb

@@ -1,25 +1,30 @@
 =begin
 
-fcgi.rb 0.8.5 - fcgi.so compatible pure-ruby FastCGI library
+fcgi.rb 0.9.2 - 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
+fcgi.rb    Copyright (C) 2011 saks and Julik Tarkhanov
+fcgi.rb    Copyright (C) 2012-2013 mva
 
 =end
 trap('SIGTERM') { exit }
 trap('SIGPIPE','IGNORE')
 
 begin
-  raise LoadError if defined?(FCGI_PURE_RUBY) && FCGI_PURE_RUBY
+  raise LoadError if ENV["USE_PURE_RUBY_FCGI"]
   require "fcgi.so"
-rescue LoadError
+rescue LoadError # Load the pure ruby version instead
+  # At this point we do have STDERR so put it to some good use
+  $stderr.puts "Your FCGI gem does not contain the FCGI shared library, running pure ruby instead"
+
   require 'socket'
   require 'stringio'
 
   class FCGI
 
-    def self::is_cgi?
+    def self.is_cgi?
       begin
         s = Socket.for_fd($stdin.fileno)
         s.getpeername
@@ -31,21 +36,21 @@ rescue LoadError
       end
     end
 
-    def self::each(&block)
+    def self.each(&block)
       f = default_connection()
       Server.new(f).each_request(&block)
     ensure
       f.close if f
     end
 
-    def self::each_request(&block)
+    def self.each_request(&block)
       f = default_connection()
       Server.new(f).each_request(&block)
     ensure
       f.close if f
     end
 
-    def self::default_connection
+    def self.default_connection
       ::Socket.for_fd($stdin.fileno)
     end
 
@@ -108,9 +113,9 @@ rescue LoadError
           exit 0 if graceful
         end
       end
-      
+
       def session
-        sock, addr = *@server.accept
+        sock, _ = *@server.accept
         return unless sock
         fsock = FastCGISocket.new(sock)
         req = next_request(fsock)
@@ -191,7 +196,7 @@ rescue LoadError
       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)
+        _, type, reqid, clen, padlen, _ = *Record.parse_header(header)
         Record.class_for(type).parse(reqid, read_record_body(clen, padlen))
       end
 
@@ -306,11 +311,11 @@ rescue LoadError
       HEADER_FORMAT = 'CCnnCC'
       HEADER_LENGTH = 8
 
-      def self::parse_header(buf)
+      def self.parse_header(buf)
         return *buf.unpack(HEADER_FORMAT)
       end
 
-      def self::class_for(type)
+      def self.class_for(type)
         RECORD_CLASS[type]
       end
 
@@ -351,7 +356,7 @@ rescue LoadError
       BODY_FORMAT = 'nCC5'
 
       def BeginRequestRecord.parse(id, body)
-        role, flags, *reserved = *body.unpack(BODY_FORMAT)
+        role, flags, *_ = *body.unpack(BODY_FORMAT)
         new(id, role, flags)
       end
 
@@ -363,6 +368,10 @@ rescue LoadError
 
       attr_reader :role
       attr_reader :flags
+
+      def make_body
+        [@role, @flags, 0, 0, 0, 0, 0].pack(BODY_FORMAT)
+      end
     end
 
     class AbortRequestRecord < Record
@@ -381,7 +390,7 @@ rescue LoadError
       # uint8_t  reserved[3];
       BODY_FORMAT = 'NCC3'
 
-      def self::parse(id, body)
+      def self.parse(id, body)
         appstatus, protostatus, *reserved = *body.unpack(BODY_FORMAT)
         new(id, appstatus, protostatus)
       end
@@ -407,7 +416,7 @@ rescue LoadError
       # uint8_t reserved[7];
       BODY_FORMAT = 'CC7'
 
-      def self::parse(id, body)
+      def self.parse(id, body)
         type, *reserved = *body.unpack(BODY_FORMAT)
         new(id, type)
       end
@@ -427,11 +436,11 @@ rescue LoadError
     end
 
     class ValuesRecord < Record
-      def self::parse(id, body)
+      def self.parse(id, body)
         new(id, parse_values(body))
       end
 
-      def self::parse_values(buf)
+      def self.parse_values(buf)
         result = {}
         until buf.empty?
           name, value = *read_pair(buf)
@@ -439,17 +448,29 @@ rescue LoadError
         end
         result
       end
-      
-      def self::read_pair(buf)
+
+      def self.read_pair(buf)
         nlen = read_length(buf)
         vlen = read_length(buf)
-        return buf.slice!(0, nlen), buf.slice!(0, vlen)
+        [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)
+
+
+      if "".respond_to?(:bytes) # Ruby 1.9 string semantics
+        def self.read_length(buf)
+          if buf[0].bytes.first >> 7 == 0
+            buf.slice!(0,1)[0].bytes.first
+          else
+            buf.slice!(0,4).unpack('N')[0] & ((1<<31) - 1)
+          end
+        end
+      else # Ruby 1.8 string
+        def self.read_length(buf)
+          if buf[0] >> 7 == 0
+            buf.slice!(0,1)[0].bytes.first
+          else
+            buf.slice!(0,4).unpack('N')[0] & ((1<<31) - 1)
+          end
         end
       end
 
@@ -498,7 +519,7 @@ rescue LoadError
     end
 
     class GenericDataRecord < Record
-      def self::parse(id, body)
+      def self.parse(id, body)
         new(id, body)
       end
 
@@ -516,7 +537,11 @@ rescue LoadError
       private
 
       def make_body
-        @flagment
+        if @flagment.respond_to? 'force_encoding' then
+          return @flagment.dup.force_encoding('BINARY')
+        else
+          return @flagment
+        end
       end
     end
 
@@ -526,6 +551,12 @@ rescue LoadError
       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
@@ -540,7 +571,9 @@ rescue LoadError
         FCGI_ABORT_REQUEST => AbortRequestRecord,
         FCGI_PARAMS        => ParamsRecord,
         FCGI_STDIN         => StdinDataRecord,
-        FCGI_DATA          => DataRecord
+        FCGI_DATA          => DataRecord,
+        FCGI_STDOUT        => StdoutDataRecord,
+        FCGI_END_REQUEST   => EndRequestRecord
       }
     end
 
@@ -552,13 +585,13 @@ end # begin
 # are defined within module 'CGI', even if you have subclassed it
 
 class FCGI
-  def self::each_cgi(*args)
+  def self.each_cgi(*args)
     require 'cgi'
-    
+
     eval(<<-EOS,TOPLEVEL_BINDING)
     class CGI
       public :env_table
-      def self::remove_params
+      def self.remove_params
         if (const_defined?(:CGI_PARAMS))
           remove_const(:CGI_PARAMS)
           remove_const(:CGI_COOKIES)
@@ -589,18 +622,18 @@ class FCGI
       end # FCGI::CGI class
     end # FCGI class
     EOS
-    
+
     if FCGI::is_cgi?
       yield ::CGI.new(*args)
     else
-      exit_requested = false
-      FCGI::each {|request|
+      FCGI::each do |request|
+
         $stdout, $stderr = request.out, request.err
 
         yield CGI.new(request, *args)
-        
+
         request.finish
-      }
+      end
     end
   end
 end

data/test/helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'fcgi'
+
+class Test::Unit::TestCase
+end

data/test/test_fcgi.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestFcgi < Test::Unit::TestCase
+  def test_something_for_real
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -1,44 +1,64 @@
---- !ruby/object:Gem::Specification 
-rubygems_version: "0.8"
-specification_version: 1
+--- !ruby/object:Gem::Specification
 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: 
+version: !ruby/object:Gem::Version
+  version: 0.9.2.2
 platform: ruby
-files: 
-  - lib
-  - extconf.rb
-  - fcgi.c
-  - MANIFEST
-  - README
-  - fcgi.gemspec
-  - lib/fcgi.rb
-test_files: []
-rdoc_options: []
-extra_rdoc_files: 
-  - README
+authors:
+- mva
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-10-17 00:00:00.000000000 Z
+dependencies: []
+description: FastCGI is a language independent, scalable, open extension to CGI that
+  provides high performance without the limitations of server specific APIs. This
+  version aims to be compatible with both 1.8.x and 1.9.x versions of Ruby, and also
+  will be ported to 2.0.x. It has been hacked to work with Ruby 3.0.x.
+email: mva@mva.name
 executables: []
-extensions: 
-  - extconf.rb
+extensions:
+- ext/fcgi/extconf.rb
+extra_rdoc_files:
+- LICENSE
+- README.rdoc
+- README.signals
+files:
+- LICENSE
+- README.rdoc
+- README.signals
+- VERSION
+- ext/fcgi/MANIFEST
+- ext/fcgi/Makefile
+- ext/fcgi/extconf.rb
+- ext/fcgi/fcgi.c
+- fcgi.gemspec
+- lib/fcgi.rb
+- test/helper.rb
+- test/test_fcgi.rb
+homepage: http://github.com/alphallc/ruby-fcgi-ng
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options:
+- "--charset=UTF-8"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-dependencies: []
+rubygems_version: 3.3.8
+signing_key:
+specification_version: 4
+summary: FastCGI library for Ruby.
+test_files:
+- test/helper.rb
+- test/test_fcgi.rb

data/extconf.rb

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