ruby-lsapi 4.2 → 5.2

data/ext/lsapi/lsapilib.h

@@ -1,21 +1,21 @@
 /*
-Copyright (c) 2002-2015, Lite Speed Technologies Inc.
+Copyright (c) 2002-2018, Lite Speed Technologies Inc.
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
-met: 
+met:
 
     * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer. 
+      notice, this list of conditions and the following disclaimer.
     * Redistributions in binary form must reproduce the above
       copyright notice, this list of conditions and the following
       disclaimer in the documentation and/or other materials provided
-      with the distribution. 
+      with the distribution.
     * Neither the name of the Lite Speed Technologies Inc nor the
       names of its contributors may be used to endorse or promote
       products derived from this software without specific prior
-      written permission.  
+      written permission.
 
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
@@ -27,7 +27,7 @@ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 
@@ -38,9 +38,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 extern "C" {
 #endif
 
-#include <stddef.h>
-#include <lsapidef.h>
+#include "lsapidef.h"
 
+#include <stddef.h>
 #include <sys/time.h>
 #include <sys/types.h>
 
@@ -52,8 +52,8 @@ struct LSAPI_key_value_pair
     int    valLen;
 };
 
-
-#define LSAPI_MAX_RESP_HEADERS  100
+struct lsapi_child_status;
+#define LSAPI_MAX_RESP_HEADERS  1000
 
 typedef struct lsapi_request
 {
@@ -65,7 +65,7 @@ typedef struct lsapi_request
 
     char            * m_pReqBuf;
     int               m_reqBufSize;
-    
+
     char            * m_pRespBuf;
     char            * m_pRespBufEnd;
     char            * m_pRespBufPos;
@@ -73,12 +73,13 @@ typedef struct lsapi_request
     char            * m_pRespHeaderBuf;
     char            * m_pRespHeaderBufEnd;
     char            * m_pRespHeaderBufPos;
+    struct lsapi_child_status * child_status;
 
 
     struct iovec    * m_pIovec;
     struct iovec    * m_pIovecEnd;
     struct iovec    * m_pIovecCur;
-    struct iovec    * m_pIovecToWrite;    
+    struct iovec    * m_pIovecToWrite;
 
     struct lsapi_packet_header      * m_respPktHeaderEnd;
 
@@ -90,7 +91,7 @@ typedef struct lsapi_request
 
     struct lsapi_http_header_index  * m_pHeaderIndex;
     struct lsapi_header_offset      * m_pUnknownHeader;
-    
+
     char            * m_pScriptFile;
     char            * m_pScriptName;
     char            * m_pQueryString;
@@ -102,9 +103,9 @@ typedef struct lsapi_request
     off_t             m_reqBodyRead;
     int               m_bufProcessed;
     int               m_bufRead;
-    
+
     struct lsapi_packet_header        m_respPktHeader[5];
-    
+
     struct lsapi_resp_header          m_respHeader;
     short                             m_respHeaderLen[LSAPI_MAX_RESP_HEADERS];
     void            * m_pAppData;
@@ -150,7 +151,6 @@ int LSAPI_ForeachSpecialEnv_r( LSAPI_Request * pReq,
             LSAPI_CB_EnvHandler fn, void * arg );
 
 char * LSAPI_GetEnv_r( LSAPI_Request * pReq, const char * name );
-            
 
 ssize_t LSAPI_ReadReqBody_r( LSAPI_Request * pReq, char * pBuf, size_t len );
 
@@ -171,7 +171,7 @@ int LSAPI_Flush_r( LSAPI_Request * pReq );
 
 int LSAPI_AppendRespHeader_r( LSAPI_Request * pReq, const char * pBuf, int len );
 
-int LSAPI_AppendRespHeader2_r( LSAPI_Request * pReq, const char * pHeaderName, 
+int LSAPI_AppendRespHeader2_r( LSAPI_Request * pReq, const char * pHeaderName,
                               const char * pHeaderValue );
 
 int LSAPI_ErrResponse_r( LSAPI_Request * pReq, int code, const char ** pRespHeaders,
@@ -248,6 +248,9 @@ static inline off_t LSAPI_GetReqBodyRemain_r( LSAPI_Request * pReq )
 }
 
 
+int LSAPI_End_Response_r(LSAPI_Request * pReq);
+
+
 
 int LSAPI_Is_Listen(void);
 
@@ -276,28 +279,28 @@ static inline int LSAPI_ForeachSpecialEnv( LSAPI_CB_EnvHandler fn, void * arg )
 static inline char * LSAPI_GetEnv( const char * name )
 {   return LSAPI_GetEnv_r( &g_req, name );                  }
 
-static inline char * LSAPI_GetQueryString()
+static inline char * LSAPI_GetQueryString(void)
 {   return LSAPI_GetQueryString_r( &g_req );                }
 
-static inline char * LSAPI_GetScriptFileName()
+static inline char * LSAPI_GetScriptFileName(void)
 {   return LSAPI_GetScriptFileName_r( &g_req );             }
 
-static inline char * LSAPI_GetScriptName()
+static inline char * LSAPI_GetScriptName(void)
 {    return LSAPI_GetScriptName_r( &g_req );                }
 
-static inline char * LSAPI_GetRequestMethod()
+static inline char * LSAPI_GetRequestMethod(void)
 {   return LSAPI_GetRequestMethod_r( &g_req );              }
 
-static inline off_t LSAPI_GetReqBodyLen()
+static inline off_t LSAPI_GetReqBodyLen(void)
 {   return LSAPI_GetReqBodyLen_r( &g_req );                 }
 
-static inline off_t LSAPI_GetReqBodyRemain()
+static inline off_t LSAPI_GetReqBodyRemain(void)
 {   return LSAPI_GetReqBodyRemain_r( &g_req );                 }
 
 static inline ssize_t LSAPI_ReadReqBody( char * pBuf, size_t len )
 {   return LSAPI_ReadReqBody_r( &g_req, pBuf, len );        }
 
-static inline int LSAPI_ReqBodyGetChar()
+static inline int LSAPI_ReqBodyGetChar(void)
 {   return LSAPI_ReqBodyGetChar_r( &g_req );        }
 
 static inline int LSAPI_ReqBodyGetLine( char * pBuf, int len, int *getLF )
@@ -313,13 +316,13 @@ static inline ssize_t LSAPI_Write( const char * pBuf, ssize_t len )
 
 static inline ssize_t LSAPI_sendfile( int fdIn, off_t* off, size_t size )
 {
-    return LSAPI_sendfile_r(&g_req, fdIn, off, size );          
+    return LSAPI_sendfile_r(&g_req, fdIn, off, size );
 }
 
 static inline ssize_t LSAPI_Write_Stderr( const char * pBuf, ssize_t len )
 {   return LSAPI_Write_Stderr_r( &g_req, pBuf, len );       }
 
-static inline int LSAPI_Flush()
+static inline int LSAPI_Flush(void)
 {   return LSAPI_Flush_r( &g_req );                         }
 
 static inline int LSAPI_AppendRespHeader( char * pBuf, int len )
@@ -331,6 +334,9 @@ static inline int LSAPI_SetRespStatus( int code )
 static inline int LSAPI_ErrResponse( int code, const char ** pRespHeaders, const char * pBody, int bodyLen )
 {   return LSAPI_ErrResponse_r( &g_req, code, pRespHeaders, pBody, bodyLen );   }
 
+static inline int LSAPI_End_Response(void)
+{   return LSAPI_End_Response_r( &g_req );                         }
+
 int LSAPI_IsRunning(void);
 
 int LSAPI_CreateListenSock( const char * pBind, int backlog );
@@ -343,6 +349,8 @@ void LSAPI_Set_Server_fd( int fd );
 
 int LSAPI_Prefork_Accept_r( LSAPI_Request * pReq );
 
+void LSAPI_No_Check_ppid(void);
+
 void LSAPI_Set_Max_Reqs( int reqs );
 
 void LSAPI_Set_Max_Idle( int secs );
@@ -359,9 +367,46 @@ int LSAPI_Init_Env_Parameters( fn_select_t fp );
 
 void LSAPI_Set_Slow_Req_Msecs( int msecs );
 
-int  LSAPI_Get_Slow_Req_Msecs( );
+int  LSAPI_Get_Slow_Req_Msecs(void);
+
+int LSAPI_is_suEXEC_Daemon(void);
+
+int LSAPI_Set_Restored_Parent_Pid(int pid);
+
+typedef void (*LSAPI_On_Timer_pf)(int *forked_child_pid);
+void LSAPI_Register_Pgrp_Timer_Callback(LSAPI_On_Timer_pf);
+
+int LSAPI_Inc_Req_Processed(int cnt);
+
+int LSAPI_Accept_Before_Fork(LSAPI_Request * pReq);
+
+int LSAPI_Postfork_Child(LSAPI_Request * pReq);
+
+int LSAPI_Postfork_Parent(LSAPI_Request * pReq);
+
+#define LSAPI_LOG_LEVEL_BITS    0xff
+#define LSAPI_LOG_FLAG_NONE     0
+#define LSAPI_LOG_FLAG_DEBUG    1
+#define LSAPI_LOG_FLAG_INFO     2
+#define LSAPI_LOG_FLAG_NOTICE   3
+#define LSAPI_LOG_FLAG_WARN     4
+#define LSAPI_LOG_FLAG_ERROR    5
+#define LSAPI_LOG_FLAG_CRIT     6
+#define LSAPI_LOG_FLAG_FATAL    7
+
+#define LSAPI_LOG_TIMESTAMP_BITS (0xff00)
+#define LSAPI_LOG_TIMESTAMP_FULL (0x100)
+#define LSAPI_LOG_TIMESTAMP_HMS  (0x200)
+#define LSAPI_LOG_TIMESTAMP_STDERR  (0x400)
+
+#define LSAPI_LOG_PID            (0x10000)
+
+void LSAPI_Log(int flag, const char * fmt, ...)
+#if __GNUC__
+        __attribute__((format(printf, 2, 3)))
+#endif
+;
 
-int LSAPI_is_suEXEC_Daemon();
 
 #if defined (c_plusplus) || defined (__cplusplus)
 }

data/ext/lsapi/lsruby.c

@@ -15,6 +15,8 @@
 #include <sys/socket.h>
 #include <sys/wait.h>
 #include <unistd.h>
+#include <sys/mman.h>
+#include <fcntl.h>
 
 /* RUBY_EXTERN VALUE ruby_errinfo; */
 RUBY_EXTERN VALUE rb_stdin;
@@ -36,6 +38,7 @@ static VALUE env_copy;
 
 static VALUE lsapi_env;
 
+static int MAX_BODYBUF_LENGTH = (10 * 1024 * 1024);
 
 /* static VALUE lsapi_objrefs; */
 
@@ -44,10 +47,8 @@ typedef struct lsapi_data
     LSAPI_Request * req;
     VALUE           env;
     ssize_t      (* fn_write)( LSAPI_Request *, const char * , size_t );
-    
 }lsapi_data;
 
-
 static VALUE cLSAPI;
 
 static VALUE s_req = Qnil;
@@ -57,17 +58,28 @@ static VALUE s_req_stderr = Qnil;
 static lsapi_data * s_stderr_data;
 static pid_t s_pid = 0;
 
-/*
-static void lsapi_ruby_setenv(const char *name, const char *value)
+typedef struct lsapi_body
 {
-    if (!name) return;
+    char        *bodyBuf;  //we put small one into memory, otherwise, into a memory mapping file, and we still use the bodyBuf to access this mapping
+    int	        bodyLen;	//expected length got form content-length
+    int	        bodyCurrentLen;	//current length by read() readBodyToReqBuf
+    int	        curPos;
+}lsapi_body;
 
-    if (value && *value)
-	    ruby_setenv(name, value);
-    else
-        ruby_unsetenv(name);
-}
-*/
+static lsapi_body	s_body;
+static char sTempFile[1024] = {0};
+
+/*
+ * static void lsapi_ruby_setenv(const char *name, const char *value)
+ * {
+ *    if (!name) return;
+ * 
+ *    if (value && *value)
+ *	    ruby_setenv(name, value);
+ *    else
+ *        ruby_unsetenv(name);
+ } *        *
+ */
 
 
 static void lsapi_mark( lsapi_data * data )
@@ -75,87 +87,87 @@ static void lsapi_mark( lsapi_data * data )
     rb_gc_mark( data->env );
 }
 /*
-static void lsapi_free_data( lsapi_data * data )
-{
-   free( data );
-}
-*/
+ * static void lsapi_free_data( lsapi_data * data )
+ * {
+ *   free( data );
+ } *        *
+ */
 static int add_env_rails( const char * pKey, int keyLen, const char * pValue, int valLen,
-                         void * arg )
+                          void * arg )
 {
     char * p;
     int len;
     /* Fixup some environment variables for rails */
     switch( *pKey )
     {
-    case 'Q':
-        if ( strcmp( pKey, "QUERY_STRING" ) == 0 )
-        {
-            if ( !*pValue )
-                return 1;
-        }
-        break;
-    case 'R':
-        if (( *(pKey+8) == 'U' )&&( strcmp( pKey, "REQUEST_URI" ) == 0 ))
-        {
-            p = strchr( pValue, '?' );
-            if ( p )
+        case 'Q':
+            if ( strcmp( pKey, "QUERY_STRING" ) == 0 )
             {
-                len = valLen - ( p - pValue ) - 1;
-                /* 
-                valLen = p - pValue;
-                *p++ = 0;
-                */
+                if ( !*pValue )
+                    return 1;
             }
-            else
+            break;
+        case 'R':
+            if (( *(pKey+8) == 'U' )&&( strcmp( pKey, "REQUEST_URI" ) == 0 ))
             {
-                p = (char *)pValue + valLen;
-                len = 0;
+                p = strchr( pValue, '?' );
+                if ( p )
+                {
+                    len = valLen - ( p - pValue ) - 1;
+                    /* 
+                     *                valLen = p - pValue;
+                     *p++ = 0;
+                     */
+                }
+                else
+                {
+                    p = (char *)pValue + valLen;
+                    len = 0;
+                }
+                rb_hash_aset( lsapi_env,rb_tainted_str_new("PATH_INFO", 9),
+                              rb_tainted_str_new(pValue, p - pValue));
+                rb_hash_aset( lsapi_env,rb_tainted_str_new("REQUEST_PATH", 12),
+                              rb_tainted_str_new(pValue, p - pValue));
+                if ( *p == '?' )
+                    ++p;
+                rb_hash_aset( lsapi_env,rb_tainted_str_new("QUERY_STRING", 12),
+                rb_tainted_str_new(p, len));
             }
-            rb_hash_aset( lsapi_env,rb_tainted_str_new("PATH_INFO", 9),
-                        rb_tainted_str_new(pValue, p - pValue));
-            rb_hash_aset( lsapi_env,rb_tainted_str_new("REQUEST_PATH", 12),
-                        rb_tainted_str_new(pValue, p - pValue));
-            if ( *p == '?' )
-                ++p;
-            rb_hash_aset( lsapi_env,rb_tainted_str_new("QUERY_STRING", 12),
-                        rb_tainted_str_new(p, len));
-        }
-        break;
-    case 'S':
-        if ( strcmp( pKey, "SCRIPT_NAME" ) == 0 )
-        {
-            pValue = "/";
-            valLen = 1;
-        }
-        break;
-    case 'P':
-        if ( strcmp( pKey, "PATH_INFO" ) == 0 )
-            return 1;
-    default:
-        break;
+            break;
+        case 'S':
+            if ( strcmp( pKey, "SCRIPT_NAME" ) == 0 )
+            {
+                pValue = "/";
+                valLen = 1;
+            }
+            break;
+        case 'P':
+            if ( strcmp( pKey, "PATH_INFO" ) == 0 )
+                return 1;
+        default:
+            break;
     }
     
     /* lsapi_ruby_setenv(pKey, pValue ); */
     
     rb_hash_aset( lsapi_env,rb_tainted_str_new(pKey, keyLen),
-                    rb_tainted_str_new(pValue, valLen));
+                  rb_tainted_str_new(pValue, valLen));
     return 1;
 }
 
 static int add_env_no_fix( const char * pKey, int keyLen, const char * pValue, int valLen,
-                         void * arg )
+                           void * arg )
 {
     rb_hash_aset( lsapi_env,rb_tainted_str_new(pKey, keyLen),
-                    rb_tainted_str_new(pValue, valLen));
+                  rb_tainted_str_new(pValue, valLen));
     return 1;
 }
 
 typedef int (*fn_add_env)( const char * pKey, int keyLen, const char * pValue, int valLen,
-                         void * arg );
-                         
+                           void * arg );
+
 fn_add_env s_fn_add_env = add_env_no_fix;
-                         
+
 static void clear_env()
 {
     /* rb_funcall( lsapi_env, rb_intern( "clear" ), 0 ); */
@@ -165,15 +177,11 @@ static void clear_env()
 static void setup_cgi_env( lsapi_data * data )
 {
     clear_env();
-
+    
     LSAPI_ForeachHeader_r( data->req, s_fn_add_env, data );
     LSAPI_ForeachEnv_r( data->req, s_fn_add_env, data );
-    
 }
 
-
-
-
 static VALUE lsapi_s_accept( VALUE self )
 {
     int pid;
@@ -181,33 +189,63 @@ static VALUE lsapi_s_accept( VALUE self )
         return Qnil;
     else
     {
-
+        if (s_body.bodyBuf != NULL)
+            free (s_body.bodyBuf);
+        
+        s_body.bodyBuf = NULL;
+        s_body.bodyLen = -1;
+        s_body.bodyCurrentLen = 0;
+        s_body.curPos = 0;    
+        
         pid = getpid();
         if ( pid != s_pid )
         {
             s_pid = pid;
             rb_funcall( Qnil, rb_intern( "srand" ), 0 );
         }
-
+        
         setup_cgi_env( s_req_data );
         return s_req;
     }
-   
 }
 
-/*
-static int chdir_file( const char * pFile )
+
+static VALUE lsapi_s_accept_new_conn(VALUE self)
+{
+    if (LSAPI_Accept_Before_Fork(&g_req) == -1 )
+        return Qnil;
+    else
+        return s_req;
+}
+
+
+static VALUE lsapi_s_postfork_child(VALUE self)
 {
-    char * p = strrchr( pFile, '/' );
-    int ret;
-    if ( !p )
-        return -1;
-    *p = 0;
-    ret = chdir( pFile );
-    *p = '/';
-    return ret;
+    LSAPI_Postfork_Child(&g_req);
+    return s_req;
 }
-*/
+
+
+static VALUE lsapi_s_postfork_parent(VALUE self)
+{
+    LSAPI_Postfork_Parent(&g_req);
+    return s_req;
+}
+
+
+/*
+ * static int chdir_file( const char * pFile )
+ * {
+ *    char * p = strrchr( pFile, '/' );
+ *    int ret;
+ *    if ( !p )
+ *        return -1;
+ *p = 0;
+ ret = chdir( pFile );
+ *p = '/';
+ return ret;
+ }
+ */
 
 static VALUE lsapi_eval_string_wrap(VALUE self, VALUE str)
 {
@@ -224,18 +262,19 @@ static VALUE lsapi_eval_string_wrap(VALUE self, VALUE str)
 
 static VALUE lsapi_process( VALUE self )
 {
-    lsapi_data *data;
+/*    lsapi_data *data;
     const char * pScriptPath;
     Data_Get_Struct(self,lsapi_data, data);
     pScriptPath = LSAPI_GetScriptFileName_r( data->req );
-/*
-   if ( chdir_file( pScriptPath ) == -1 )
-   {
-       lsapi_send_error( 404 );
-   }
-   rb_load_file( pScriptPath );
 */
-   return Qnil;
+    /*
+     *   if ( chdir_file( pScriptPath ) == -1 )
+     *   {
+     *       lsapi_send_error( 404 );
+     *   }
+     *   rb_load_file( pScriptPath );
+     */
+    return Qnil;
 }
 
 
@@ -256,9 +295,9 @@ static VALUE lsapi_write( VALUE self, VALUE str )
     lsapi_data *data;
     int len;
     Data_Get_Struct(self,lsapi_data, data);
-/*    len = LSAPI_Write_r( data->req, RSTRING_PTR(str), RSTRING_LEN(str) ); */
+    /*    len = LSAPI_Write_r( data->req, RSTRING_PTR(str), RSTRING_LEN(str) ); */
     if (TYPE(str) != T_STRING)
-	    str = rb_obj_as_string(str);
+        str = rb_obj_as_string(str);
     len = (*data->fn_write)( data->req, RSTRING_PTR(str), RSTRING_LEN(str) );
     return INT2NUM( len );
 }
@@ -267,13 +306,13 @@ static VALUE lsapi_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;
+        argc = 1;
+        line = rb_lastline_get();
+        argv = &line;
     }
     for (i = 0; i<argc; i++)
     {
@@ -283,19 +322,19 @@ static VALUE lsapi_print( int argc, VALUE *argv, VALUE out )
         }
         switch (TYPE(argv[i]))
         {
-        case T_NIL:
-            lsapi_write(out, rb_str_new2("nil"));
-            break;
-        default:
-            lsapi_write(out, argv[i]);
-            break;
+            case T_NIL:
+                lsapi_write(out, rb_str_new2("nil"));
+                break;
+            default:
+                lsapi_write(out, argv[i]);
+                break;
         }
     }
     if (!NIL_P(rb_output_rs))
     {
         lsapi_write(out, rb_output_rs);
     }
-
+    
     return Qnil;
 }
 
@@ -312,8 +351,8 @@ static VALUE lsapi_puts_ary(VALUE ary, VALUE out, int recur )
 {
     VALUE tmp;
     long i;
-
-    if (recur) 
+    
+    if (recur)
     {
         tmp = rb_str_new2("[...]");
         rb_io_puts(1, &tmp, out);
@@ -325,22 +364,22 @@ static VALUE lsapi_puts_ary(VALUE ary, VALUE out, int recur )
         rb_io_puts(1, &tmp, out);
     }
     return Qnil;
-
+    
 }
 #else
 static VALUE lsapi_puts_ary(VALUE ary, VALUE out)
 {
     VALUE tmp;
     int i;
-
+    
     for (i=0; i<RARRAY_LEN(ary); i++)
     {
         tmp = RARRAY_PTR(ary)[i];
-	    if (rb_inspecting_p(tmp))
+        if (rb_inspecting_p(tmp))
         {
-	        tmp = rb_str_new2("[...]");
-	    }
-	    lsapi_puts(1, &tmp, out);
+            tmp = rb_str_new2("[...]");
+        }
+        lsapi_puts(1, &tmp, out);
     }
     return Qnil;
 }
@@ -350,7 +389,7 @@ static VALUE lsapi_puts(int argc, VALUE *argv, VALUE out)
 {
     int i;
     VALUE line;
-
+    
     /* if no argument given, print newline. */
     if (argc == 0)
     {
@@ -361,19 +400,19 @@ static VALUE lsapi_puts(int argc, VALUE *argv, VALUE out)
     {
         switch (TYPE(argv[i]))
         {
-        case T_NIL:
-            line = rb_str_new2("nil");
-            break;
-        case T_ARRAY:
+            case T_NIL:
+                line = rb_str_new2("nil");
+                break;
+            case T_ARRAY:
 #if defined( RUBY_19 ) || defined( RUBY_2 )
-            rb_exec_recursive(lsapi_puts_ary, argv[i], out);
+                rb_exec_recursive(lsapi_puts_ary, argv[i], out);
 #else
-            rb_protect_inspect(lsapi_puts_ary, argv[i], out);
+                rb_protect_inspect(lsapi_puts_ary, argv[i], out);
 #endif
-            continue;
-        default:
-            line = argv[i];
-            break;
+                continue;
+            default:
+                line = argv[i];
+                break;
         }
         line = rb_obj_as_string(line);
         lsapi_write(out, line);
@@ -382,7 +421,7 @@ static VALUE lsapi_puts(int argc, VALUE *argv, VALUE out)
             lsapi_write(out, rb_default_rs);
         }
     }
-
+    
     return Qnil;
 }
 
@@ -395,10 +434,10 @@ static VALUE lsapi_addstr(VALUE out, VALUE str)
 
 static VALUE lsapi_flush( VALUE self )
 {
-/*
-    lsapi_data *data;
-    Data_Get_Struct(self,lsapi_data, data);
-*/
+    /*
+     *    lsapi_data *data;
+     *    Data_Get_Struct(self,lsapi_data, data);
+     */
     LSAPI_Flush_r( &g_req ); 
     return Qnil;
 }
@@ -406,10 +445,10 @@ static VALUE lsapi_flush( VALUE self )
 static VALUE lsapi_getc( VALUE self )
 {
     int ch;
-/*
-    lsapi_data *data;
-    Data_Get_Struct(self,lsapi_data, data);
-*/
+    /*
+     *    lsapi_data *data;
+     *    Data_Get_Struct(self,lsapi_data, data);
+     */
     if (rb_safe_level() >= 4 && !OBJ_TAINTED(self))
     {
         rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
@@ -420,88 +459,250 @@ static VALUE lsapi_getc( VALUE self )
     return INT2NUM( ch );
 }
 
+static inline int isBodyWriteToFile()
+{
+    return ((s_body.bodyLen >= MAX_BODYBUF_LENGTH)? (1): (0));
+}
+
+//create a temp file and open it, if failed, fd = -1
+static inline int createTempFile()
+{
+    int fd = -1;
+    char *sfn = strdup(sTempFile);
+    
+    if ((fd = mkstemp(sfn)) == -1)
+    {
+        fprintf(stderr, "%s: %s\n", sfn, strerror(errno));
+    }
+    else
+        unlink(sfn);
+    
+    free(sfn);
+    return fd;
+}
+
+//return 1 if error occured!
+//if already created, always OK (0)
+static int createBodyBuf()
+{
+    int fd = -1;
+    if (s_body.bodyLen == -1)
+    {
+        s_body.bodyLen = LSAPI_GetReqBodyLen_r(&g_req);
+        //Error if get a zeor length, should not happen 
+        if (s_body.bodyLen < 0)
+        {
+            //Wrong bode length will be treated as 0
+            s_body.bodyLen = 0;
+        }
+        
+        if (s_body.bodyLen > 0) 
+        {
+            if (isBodyWriteToFile())
+            {
+                //create file mapping
+                fd = createTempFile();
+                if (fd == -1)
+                {
+                    return 1;
+                }
+                if (ftruncate(fd, s_body.bodyLen) == 0)
+                {
+                    perror("ftruncate() failed. \n");
+                    close(fd);
+                    return 1;
+                }
+                s_body.bodyBuf = mmap(NULL, s_body.bodyLen, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+                if (s_body.bodyBuf == MAP_FAILED)
+                {
+                    perror("File mapping failed. \n");
+                    close(fd);
+                    return 1;
+                }
+                close(fd);  //close since needn't it anymore
+            }
+            else
+            {
+                s_body.bodyBuf = (char *)calloc(s_body.bodyLen, sizeof(char));
+                if (s_body.bodyBuf == NULL)
+                {
+                    perror("Memory calloc error");
+                    return 1;
+                }
+            }
+        }
+    }
+
+    return 0;   
+}
+
+static inline int isAllBodyRead()
+{
+    return (s_body.bodyCurrentLen < s_body.bodyLen)? 0 : 1;
+}
+
+static inline int isEofBodyBuf()
+{
+    return (s_body.curPos < s_body.bodyLen) ? 0 : 1;
+}
+//try to read length as times pagesize (such as 8KB * N)
+static int readBodyBuf(const int needRead)
+{
+    const int blockSize = 8192;
+    char *buff = s_body.bodyBuf + s_body.bodyCurrentLen;
+    int nRead;
+    int readMore = (needRead + blockSize -1) / blockSize * blockSize;
+    int remain = LSAPI_GetReqBodyRemain_r( &g_req );
+    //Only when not enough left, needReadChange will be changed!!!
+    if (remain < readMore) 
+        readMore = remain;
+
+    if ( readMore <= 0 )
+        return 0;
+    
+    nRead = LSAPI_ReadReqBody_r(&g_req, buff, readMore);
+    if ( nRead > 0 )
+        s_body.bodyCurrentLen += nRead;
+
+    return nRead;
+}
+
 static VALUE lsapi_gets( VALUE self )
 {
     VALUE str;
-    int getLF = 0;
-    char buff[4096];
-    int len;
+    const int blkSize = 4096;
+    int n;
+    char *p = NULL;
+    
     if (rb_safe_level() >= 4 && !OBJ_TAINTED(self))
     {
         rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
     }
-    if ( LSAPI_GetReqBodyRemain_r( &g_req ) <= 0 )
+    
+    if (createBodyBuf() == 1)
+    {
         return Qnil;
-    str = rb_str_buf_new( 1024 );
+    }   
+    
+    //comment:
+    while((p = memmem(s_body.bodyBuf + s_body.curPos, s_body.bodyCurrentLen - s_body.curPos, "\n", 1)) == NULL) 
+    {
+        if (isAllBodyRead() == 1)
+            break;
+        //read one page and check, then reply
+        readBodyBuf(blkSize);
+    }
+    
+    p = memmem(s_body.bodyBuf + s_body.curPos, s_body.bodyCurrentLen - s_body.curPos, "\n", 1);
+    if (p != NULL)
+        n = p - s_body.bodyBuf - s_body.curPos + 1;
+    else
+        n = s_body.bodyCurrentLen - s_body.curPos;
+    
+    str = rb_str_buf_new( n );
     OBJ_TAINT(str);
-    while( !getLF )
+    
+    if (n > 0)
     {
-        len = LSAPI_ReqBodyGetLine_r( &g_req, buff, 4096, &getLF );
-        if ( len > 0 )
-            rb_str_buf_cat( str, buff, len );
-        
+        rb_str_buf_cat( str, s_body.bodyBuf + s_body.curPos, n );
+        s_body.curPos += n;
     }
-    if (RSTRING_LEN(str) == 0)
-        return Qnil;
+    
     return str;
 }
 
-
 static VALUE lsapi_read(int argc, VALUE *argv, VALUE self)
 {
     VALUE str;
     int n;
-    int remain;
-    char buff[8192];
-
+    int needRead;
+    int nRead;
+    
     if (rb_safe_level() >= 4 && !OBJ_TAINTED(self))
     {
         rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
     }
-
-
-    remain = LSAPI_GetReqBodyRemain_r( &g_req );
-    if ( remain <= 0 )
+    
+    if (createBodyBuf() == 1)
+    {
         return Qnil;
-    if (argc != 0)
+    }
+    
+    //we need to consider these 4 cases:
+    //1, need all data since argc == 0, we may have all data 2, or not
+    //3, need a length of data (argv >= 1), we may have enough data already read, 4, or not
+    if (argc == 0)
+        n = s_body.bodyLen - s_body.curPos;
+    else
     {
-        n = NUM2INT(argv[0]);
-        if ( remain > n )
-            remain = n;
+        n = NUM2INT(argv[0]); //request that length from currentpos
+        if (n < 0)
+            return Qnil;
+        if (n > s_body.bodyLen - s_body.curPos)
+            n = s_body.bodyLen - s_body.curPos;            
     }
-    str = rb_str_buf_new( remain );
+    needRead = s_body.curPos + n - s_body.bodyCurrentLen;
+    if (needRead < 0)
+        needRead = 0;
+    
+    str = rb_str_buf_new( n );
     OBJ_TAINT(str);
-    while( remain > 0 )
+    if (n == 0)
+        return str;
+    
+    //copy already have part first
+    if (n - needRead != 0)
     {
-        n = LSAPI_ReadReqBody_r(&g_req, buff,
-                        (remain > 8192)?8192:remain );
-        if ( n > 0 )
-        {
-            rb_str_buf_cat( str, buff, n );
-            remain -= n;
-        }
-        else if ( n <= 0 )
+        rb_str_buf_cat( str, s_body.bodyBuf + s_body.curPos, n - needRead);
+        s_body.curPos += (n - needRead);
+    }
+    
+    if (needRead > 0)
+    {
+        //try to read needRead, but may be less (changed) when read the end of the data
+        nRead = readBodyBuf(needRead);
+        if (nRead > 0)
         {
-            /* FIXME: broken connection */
-            break;
+            n = ((nRead < needRead) ? nRead : needRead);
+            rb_str_buf_cat( str, s_body.bodyBuf + s_body.curPos, n );
+            s_body.curPos += n;
         }
     }
-    if (RSTRING_LEN(str) == 0)
-        return Qnil;
+    
     return str;
 }
 
-static VALUE lsapi_eof(VALUE self)
+static VALUE lsapi_rewind(VALUE self)
+{  
+    s_body.curPos = 0;
+    return self;
+}
+
+static VALUE lsapi_each(int argc, VALUE *argv, VALUE self)
 {
-/*
-   lsapi_data *data;
+    VALUE str;
+    lsapi_rewind(self);
+   
+    while(isEofBodyBuf() != 1)
+    {
+        str = lsapi_gets(self);
+        rb_yield(str);
+    }
+    return self;
 
-   if (rb_safe_level() >= 4 && !OBJ_TAINTED(self))
-   {
-       rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
-   }
-   Data_Get_Struct(self, lsapi_data, data);
-*/
+}
+
+static VALUE lsapi_eof(VALUE self)
+{
+    /*
+     *   lsapi_data *data;
+     * 
+     *   if (rb_safe_level() >= 4 && !OBJ_TAINTED(self))
+     *   {
+     *       rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
+}
+Data_Get_Struct(self, lsapi_data, data);
+        */
     return (LSAPI_GetReqBodyRemain_r( &g_req ) <= 0) ? Qtrue : Qfalse;
 }
 
@@ -527,7 +728,22 @@ static VALUE lsapi_setsync(VALUE self,VALUE sync)
 
 static VALUE lsapi_close(VALUE self)
 {
-    LSAPI_Flush_r( &g_req );    
+    LSAPI_Flush_r( &g_req );
+    if (isBodyWriteToFile())
+    {
+        //msync(s_body.bodyBuf, s_body.bodyLen, MS_SYNC);
+        //sleep(5);
+        munmap(s_body.bodyBuf, s_body.bodyLen);
+    }
+    else
+        free(s_body.bodyBuf);
+    
+    s_body.bodyBuf = NULL;
+    s_body.bodyLen = -1;
+    s_body.bodyCurrentLen = 0;
+    s_body.curPos = 0;    
+    //Should the temp be deleted here?!
+        
     return Qnil;
 }
 
@@ -540,42 +756,86 @@ static VALUE lsapi_reopen( int argc, VALUE *argv, VALUE self)
         /* constant silence hack */
         orig_verbose = (VALUE)ruby_verbose;
         ruby_verbose = Qnil;
-
+        
         rb_define_global_const("STDERR", orig_stderr);
-
+        
         ruby_verbose = (VALUE)orig_verbose;
-
+        
         return rb_funcall2( orig_stderr, rb_intern( "reopen" ), argc, argv );
-
+        
     }
     return self;
 }
 
+static void readMaxBodyBufLength()
+{
+    int n;
+    const char *p = getenv( "LSAPI_MAX_BODYBUF_LENGTH" );
+    if ( p )
+    {
+        n = atoi( p );
+        if (n > 0)
+        {
+            if (strstr(p, "M") || strstr(p, "m"))
+                MAX_BODYBUF_LENGTH = n * 1024 * 1024;
+            else if (strstr(p, "K") || strstr(p, "k"))
+                MAX_BODYBUF_LENGTH = n * 1024;
+            else
+                MAX_BODYBUF_LENGTH = n;
+        }
+    }
+}
 
+static void readTempFileTemplate()
+{
+    const char *p = getenv( "LSAPI_TEMPFILE" );
+    if (p == NULL || strlen(p) > 1024 - 7)
+         p = "/tmp/lsapi.XXXXXX";
+    
+    strcpy(sTempFile, p);
+    if (strlen(p) <= 6 || strcmp(p + (strlen(p) - 6), "XXXXXX") != 0)
+        strcat(sTempFile, ".XXXXXX");
+}
 
+static void initBodyBuf()
+{
+    s_body.bodyBuf = NULL;
+    s_body.bodyLen = -1;
+    s_body.bodyCurrentLen = 0;
+    s_body.curPos = 0;    
+}
 void Init_lsapi()
 {
-    VALUE remove_env;
     VALUE orig_verbose; 
     char * p;
-
+    int prefork = 0;
     LSAPI_Init();
+    initBodyBuf();
+    
+    readMaxBodyBufLength();
+    readTempFileTemplate();
+    
+    p = getenv("LSAPI_CHILDREN");
+    if (p && atoi(p) > 1)
+        prefork = 1;
 
-    //LSAPI_Init_Env_Parameters( rb_thread_select );
+#ifdef rb_thread_select
+    LSAPI_Init_Env_Parameters( rb_thread_select );
+#else
     LSAPI_Init_Env_Parameters( select );
-
+#endif
+    
     s_pid = getpid();
-
-    p = getenv( "RAILS_ROOT" );
+    
+    p = getenv( "RACK_ROOT" );
     if ( p )
     {
         if ( chdir( p ) == -1 )
             perror( "chdir()" );
     }
-    if ( p || getenv( "RAILS_ENV" ) )
+    if ( p || getenv( "RACK_ENV" ) )
         s_fn_add_env = add_env_rails;
-
-                
+    
     orig_stdin = rb_stdin;
     orig_stdout = rb_stdout;
     orig_stderr = rb_stderr;
@@ -587,19 +847,20 @@ void Init_lsapi()
     
     /* tell the garbage collector it is a global variable, do not recycle it. */
     rb_global_variable(&env_copy);
-
-    rb_hash_aset( env_copy,rb_tainted_str_new("GATEWAY_INTERFACE", 17),
-                        rb_tainted_str_new("CGI/1.2", 7));
     
-    /* Do not need those environments after initialization */
-    /* remove_env = rb_str_new( "RAILS_ROOT", 10 );
-    rb_funcall( env_copy, rb_intern( "delete" ), 1, remove_env );
-    */
-
+    rb_hash_aset( env_copy,rb_tainted_str_new("GATEWAY_Irewindable_input.rbNTERFACE", 17),
+                                              rb_tainted_str_new("CGI/1.2", 7));
+        
     rb_define_global_function("eval_string_wrap", lsapi_eval_string_wrap, 1);
-
+    
     cLSAPI = rb_define_class("LSAPI", rb_cObject);
     rb_define_singleton_method(cLSAPI, "accept", lsapi_s_accept, 0);
+    if (prefork)
+    {
+        rb_define_singleton_method(cLSAPI, "accept_new_connection", lsapi_s_accept_new_conn, 0);
+        rb_define_singleton_method(cLSAPI, "postfork_child", lsapi_s_postfork_child, 0);
+        rb_define_singleton_method(cLSAPI, "postfork_parent", lsapi_s_postfork_parent, 0);
+    }
 
     rb_define_method(cLSAPI, "process", lsapi_process, 0 );
     /* rb_define_method(cLSAPI, "initialize", lsapi_initialize, 0); */
@@ -613,11 +874,14 @@ void Init_lsapi()
     rb_define_method(cLSAPI, "getc", lsapi_getc, 0);
     /* rb_define_method(cLSAPI, "ungetc", lsapi_ungetc, 1); */
     rb_define_method(cLSAPI, "gets", lsapi_gets, 0);
-
+    
     //TEST: adding readline function to make irb happy?
     /*rb_define_method(cLSAPI, "readline", lsapi_gets, 0); */
-
+    
     rb_define_method(cLSAPI, "read", lsapi_read, -1);
+    rb_define_method(cLSAPI, "rewind", lsapi_rewind, 0);
+    rb_define_method(cLSAPI, "each", lsapi_each, 0);
+    
     rb_define_method(cLSAPI, "eof", lsapi_eof, 0);
     rb_define_method(cLSAPI, "eof?", lsapi_eof, 0);
     rb_define_method(cLSAPI, "close", lsapi_close, 0);
@@ -629,34 +893,34 @@ void Init_lsapi()
     rb_define_method(cLSAPI, "sync=", lsapi_setsync, 1);
     rb_define_method(cLSAPI, "reopen", lsapi_reopen, -1 );
     
-        
+    
     s_req = Data_Make_Struct( cLSAPI, lsapi_data, lsapi_mark, free, s_req_data );
     s_req_data->req = &g_req;
     s_req_data->fn_write = LSAPI_Write_r;
     rb_stdin = rb_stdout = s_req;
-
+    
 #if RUBY_VERSION_CODE < 180
     rb_defout = s_req;
 #endif
     rb_global_variable(&s_req );
-
+    
     s_req_stderr = Data_Make_Struct( cLSAPI, lsapi_data, lsapi_mark, free, s_stderr_data );
     s_stderr_data->req = &g_req;
     s_stderr_data->fn_write = LSAPI_Write_Stderr_r;
     rb_stderr = s_req_stderr;
     rb_global_variable(&s_req_stderr );
-
+    
     /* constant silence hack */
     orig_verbose = (VALUE)ruby_verbose;
     ruby_verbose = Qnil;
-
+    
     lsapi_env = rb_hash_new();
     clear_env();
     /* redefine ENV using a hash table, should be faster than char **environment */
     rb_define_global_const("ENV", lsapi_env);
     
     rb_define_global_const("STDERR", rb_stderr);
-
+    
     ruby_verbose = (VALUE)orig_verbose;
     
     return;