ruby-lsapi 5.7 → 5.9

data/ext/lsapi/lsruby.c

@@ -12,10 +12,17 @@
 #endif
 
 #include "lsapilib.h"
+#include <ctype.h>
 #include <errno.h>
+#include <inttypes.h>
+#include <limits.h>
 #include <netinet/in.h>
 #include <netinet/tcp.h>
 #include <signal.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 #include <sys/socket.h>
 #include <sys/wait.h>
 #include <unistd.h>
@@ -46,7 +53,7 @@ static VALUE env_copy;
 
 static VALUE lsapi_env;
 
-static int MAX_BODYBUF_LENGTH = (10 * 1024 * 1024);
+static size_t MAX_BODYBUF_LENGTH = (10 * 1024 * 1024);
 
 #if RUBY_API_VERSION_CODE >= 20700
 # if defined rb_tainted_str_new
@@ -65,6 +72,7 @@ typedef struct lsapi_data
 }lsapi_data;
 
 static VALUE cLSAPI;
+static VALUE eLSAPIConnectionError;
 
 static VALUE s_req = Qnil;
 static lsapi_data * s_req_data;
@@ -76,9 +84,10 @@ static pid_t s_pid = 0;
 typedef struct lsapi_body
 {
     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;
+    off_t       bodyLen;	//expected length got form content-length
+    off_t       bodyCurrentLen;	//current length by read() readBodyToReqBuf
+    off_t       curPos;
+    int         isMapped;
 }lsapi_body;
 
 static lsapi_body	s_body;
@@ -99,7 +108,8 @@ static char sTempFile[1024] = {0};
 
 static void lsapi_mark( lsapi_data * data )
 {
-    rb_gc_mark( data->env );
+    if (data)
+        rb_gc_mark( data->env );
 }
 /*
  * static void lsapi_free_data( lsapi_data * data )
@@ -112,20 +122,22 @@ static int add_env_rails( const char * pKey, int keyLen, const char * pValue, in
 {
     char * p;
     int len;
+    if (!pKey || keyLen <= 0 || !pValue || valLen < 0)
+        return 1;
     /* Fixup some environment variables for rails */
     switch( *pKey )
     {
         case 'Q':
-            if ( strcmp( pKey, "QUERY_STRING" ) == 0 )
+            if (keyLen == 12 && memcmp(pKey, "QUERY_STRING", 12) == 0)
             {
-                if ( !*pValue )
+                if (valLen == 0)
                     return 1;
             }
             break;
         case 'R':
-            if (( *(pKey+8) == 'U' )&&( strcmp( pKey, "REQUEST_URI" ) == 0 ))
+            if (keyLen == 11 && memcmp(pKey, "REQUEST_URI", 11) == 0)
             {
-                p = strchr( pValue, '?' );
+                p = memchr( pValue, '?', valLen );
                 if ( p )
                 {
                     len = valLen - ( p - pValue ) - 1;
@@ -143,21 +155,21 @@ static int add_env_rails( const char * pKey, int keyLen, const char * pValue, in
                               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 == '?' )
+                if (p != pValue + valLen)
                     ++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 )
+            if (keyLen == 11 && memcmp(pKey, "SCRIPT_NAME", 11) == 0)
             {
                 pValue = "/";
                 valLen = 1;
             }
             break;
         case 'P':
-            if ( strcmp( pKey, "PATH_INFO" ) == 0 )
+            if (keyLen == 9 && memcmp(pKey, "PATH_INFO", 9) == 0)
                 return 1;
         default:
             break;
@@ -173,6 +185,8 @@ static int add_env_rails( const char * pKey, int keyLen, const char * pValue, in
 static int add_env_no_fix( const char * pKey, int keyLen, const char * pValue, int valLen,
                            void * arg )
 {
+    if (!pKey || keyLen <= 0 || !pValue || valLen < 0)
+        return 1;
     rb_hash_aset( lsapi_env,rb_tainted_str_new(pKey, keyLen),
                   rb_tainted_str_new(pValue, valLen));
     return 1;
@@ -183,7 +197,7 @@ typedef int (*fn_add_env)( const char * pKey, int keyLen, const char * pValue, i
 
 fn_add_env s_fn_add_env = add_env_no_fix;
 
-static void clear_env()
+static void clear_env(void)
 {
     /* rb_funcall( lsapi_env, rb_intern( "clear" ), 0 ); */
     rb_funcall( lsapi_env, rb_intern( "replace" ), 1, env_copy );
@@ -197,21 +211,32 @@ static void setup_cgi_env( lsapi_data * data )
     LSAPI_ForeachEnv_r( data->req, s_fn_add_env, data );
 }
 
+static void resetBodyBuf(void)
+{
+    if (s_body.bodyBuf != NULL)
+    {
+        if (s_body.isMapped)
+            munmap(s_body.bodyBuf, (size_t)s_body.bodyLen);
+        else
+            free(s_body.bodyBuf);
+    }
+
+    s_body.bodyBuf = NULL;
+    s_body.bodyLen = -1;
+    s_body.bodyCurrentLen = 0;
+    s_body.curPos = 0;
+    s_body.isMapped = 0;
+}
+
+
 static VALUE lsapi_s_accept( VALUE self )
 {
     int pid;
+    resetBodyBuf();
     if ( LSAPI_Prefork_Accept_r( &g_req ) == -1 )
         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 )
         {
@@ -248,6 +273,13 @@ static VALUE lsapi_s_postfork_parent(VALUE self)
 }
 
 
+static VALUE lsapi_s_postfork_failed(VALUE self)
+{
+    LSAPI_Postfork_Failed(&g_req);
+    return Qnil;
+}
+
+
 /*
  * static int chdir_file( const char * pFile )
  * {
@@ -295,28 +327,77 @@ static VALUE lsapi_process( VALUE self )
 }
 
 
+//Output written while no request is active (application load, or after the
+//last request) must not reach the LSAPI connection.  m_fd alone is not
+//enough: in connected/pipe mode it is set before any request is read.
+//Response output is discarded, as it always has been, and stderr goes to the
+//real fd 2.  A failure during a request raises LSAPI::ConnectionError, so the
+//runner can drop the request when the client goes away.
+static inline int isRequestActive(lsapi_data *data)
+{
+    return data->req->m_reqState != 0;
+}
+
+
+static void raiseConnectionError(const char *message)
+{
+    rb_raise(eLSAPIConnectionError, "%s", message);
+}
+
+
+//write output produced outside a request; returns bytes consumed
+static long writeInactive(lsapi_data *data, const char *pBuf, long len)
+{
+    long done = 0;
+    ssize_t n;
+
+    if (data->fn_write == LSAPI_Write_r)
+        return len;     //discarded, but consumed
+    while (done < len)
+    {
+        n = write(STDERR_FILENO, pBuf + done, (size_t)(len - done));
+        if (n > 0)
+            done += n;
+        else if (n == -1 && errno == EINTR)
+            continue;
+        else
+            rb_sys_fail("write to stderr");
+    }
+    return done;
+}
+
+
 static VALUE lsapi_putc(VALUE self, VALUE c)
 {
     char ch = NUM2CHR(c);
     lsapi_data *data;
     Data_Get_Struct(self,lsapi_data, data);
+    if (!isRequestActive(data))
+    {
+        writeInactive(data, &ch, 1);
+        return c;
+    }
     if ( (*data->fn_write)( data->req, &ch, 1 ) == 1 )
         return c;
-    else
-        return INT2NUM( EOF );
+    raiseConnectionError("LSAPI response write failed");
+    return Qnil;
 }
 
 
 static VALUE lsapi_write( VALUE self, VALUE str )
 {
     lsapi_data *data;
-    int len;
+    ssize_t len;
     Data_Get_Struct(self,lsapi_data, data);
     /*    len = LSAPI_Write_r( data->req, RSTRING_PTR(str), RSTRING_LEN(str) ); */
     if (TYPE(str) != T_STRING)
         str = rb_obj_as_string(str);
+    if (!isRequestActive(data))
+        return LONG2NUM(writeInactive(data, RSTRING_PTR(str), RSTRING_LEN(str)));
     len = (*data->fn_write)( data->req, RSTRING_PTR(str), RSTRING_LEN(str) );
-    return INT2NUM( len );
+    if (len < 0)
+        raiseConnectionError("LSAPI response write failed");
+    return LONG2NUM((long)len);
 }
 
 static VALUE lsapi_print( int argc, VALUE *argv, VALUE out )
@@ -433,7 +514,8 @@ static VALUE lsapi_puts(int argc, VALUE *argv, VALUE out)
         }
         line = rb_obj_as_string(line);
         lsapi_write(out, line);
-        if (*( RSTRING_PTR(line) + RSTRING_LEN(line) - 1 ) != '\n')
+        if (RSTRING_LEN(line) == 0 ||
+            *( RSTRING_PTR(line) + RSTRING_LEN(line) - 1 ) != '\n')
         {
             lsapi_write(out, rb_default_rs);
         }
@@ -455,142 +537,195 @@ static VALUE lsapi_flush( VALUE self )
      *    lsapi_data *data;
      *    Data_Get_Struct(self,lsapi_data, data);
      */
-    LSAPI_Flush_r( &g_req ); 
+    int active = (g_req.m_reqState != 0);
+    if (LSAPI_Flush_r( &g_req ) == -1 && active)
+        raiseConnectionError("LSAPI response flush failed");
     return Qnil;
 }
 
-static VALUE lsapi_getc( VALUE self )
+static inline int isBodyWriteToFile(void)
 {
-    int ch;
-    /*
-     *    lsapi_data *data;
-     *    Data_Get_Struct(self,lsapi_data, data);
-     */
-#if RUBY_API_VERSION_CODE < 20700
-    if (rb_safe_level() >= 4 && !OBJ_TAINTED(self))
-    {
-        rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
-    }
-#endif
-    ch = LSAPI_ReqBodyGetChar_r( &g_req );
-    if ( ch == EOF )
-        return Qnil;
-    return INT2NUM( ch );
+    return s_body.bodyLen >= 0 &&
+           (uintmax_t)s_body.bodyLen >= (uintmax_t)MAX_BODYBUF_LENGTH;
 }
 
-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()
+static inline int createTempFile(void)
 {
-    int fd = -1;
-    char *sfn = strdup(sTempFile);
-    
-    if ((fd = mkstemp(sfn)) == -1)
-    {
+    int fd;
+    char sfn[sizeof(sTempFile)];
+
+    memcpy(sfn, sTempFile, sizeof(sfn));
+    fd = mkstemp(sfn);
+    if (fd == -1)
         fprintf(stderr, "%s: %s\n", sfn, strerror(errno));
-    }
     else
         unlink(sfn);
-    
-    free(sfn);
+
     return fd;
 }
 
-//return 1 if error occured!
+
+//return 1 if error occurred
 //if already created, always OK (0)
-static int createBodyBuf()
+static int createBodyBuf(void)
 {
-    int fd = -1;
-    if (s_body.bodyLen == -1)
+    int fd;
+    off_t bodyLen;
+
+    if (s_body.bodyLen != -1)
+        return 0;
+
+    bodyLen = LSAPI_GetReqBodyLen_r(&g_req);
+    /* A missing Content-Length is valid for requests whose transport has
+       already decoded framing (for example chunked HTTP/1 or HTTP/2).  The
+       LSAPI peer normally supplies the decoded length; retain the historical
+       empty-body behavior when it is genuinely unavailable. */
+    if (bodyLen < 0)
+        bodyLen = 0;
+    if ((uintmax_t)bodyLen > (uintmax_t)SIZE_MAX ||
+        (uintmax_t)bodyLen > (uintmax_t)LONG_MAX)
     {
-        s_body.bodyLen = LSAPI_GetReqBodyLen_r(&g_req);
-        //Error if get a zeor length, should not happen 
-        if (s_body.bodyLen < 0)
+        errno = EOVERFLOW;
+        return 1;
+    }
+    s_body.bodyLen = bodyLen;
+
+    if (bodyLen == 0)
+        return 0;
+
+    if (isBodyWriteToFile())
+    {
+        fd = createTempFile();
+        if (fd == -1)
+            return 1;
+        if (ftruncate(fd, bodyLen) != 0)
         {
-            //Wrong bode length will be treated as 0
-            s_body.bodyLen = 0;
+            int saved_errno = errno;
+            close(fd);
+            errno = saved_errno;
+            return 1;
         }
-        
-        if (s_body.bodyLen > 0) 
+        s_body.bodyBuf = mmap(NULL, (size_t)bodyLen, PROT_READ | PROT_WRITE,
+                              MAP_SHARED, fd, 0);
+        if (s_body.bodyBuf == MAP_FAILED)
         {
-            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;
-                }
-            }
+            int saved_errno = errno;
+            s_body.bodyBuf = NULL;
+            close(fd);
+            errno = saved_errno;
+            return 1;
         }
+        s_body.isMapped = 1;
+        close(fd);
+    }
+    else
+    {
+        s_body.bodyBuf = (char *)malloc((size_t)bodyLen);
+        if (s_body.bodyBuf == NULL)
+            return 1;
     }
 
-    return 0;   
+    return 0;
 }
 
-static inline int isAllBodyRead()
+
+static void raiseBodyError(const char *message)
 {
-    return (s_body.bodyCurrentLen < s_body.bodyLen)? 0 : 1;
+    int saved_errno = errno;
+    resetBodyBuf();
+    errno = saved_errno ? saved_errno : EIO;
+    rb_sys_fail(message);
 }
 
-static inline int isEofBodyBuf()
+
+static inline int isAllBodyRead(void)
 {
-    return (s_body.curPos < s_body.bodyLen) ? 0 : 1;
+    return s_body.bodyCurrentLen >= s_body.bodyLen;
 }
-//try to read length as times pagesize (such as 8KB * N)
-static int readBodyBuf(const int needRead)
+
+
+static inline int isEofBodyBuf(void)
 {
-    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;
+    return s_body.bodyLen >= 0 && s_body.curPos >= s_body.bodyLen;
+}
+
+
+//try to read length as multiples of 8KB
+static ssize_t readBodyBuf(off_t needRead)
+{
+    const off_t blockSize = 8192;
+    off_t available = s_body.bodyLen - s_body.bodyCurrentLen;
+    off_t readMore;
+    off_t remain;
+    ssize_t nRead;
 
-    if ( readMore <= 0 )
+    if (available <= 0)
         return 0;
-    
-    nRead = LSAPI_ReadReqBody_r(&g_req, buff, readMore);
-    if ( nRead > 0 )
-        s_body.bodyCurrentLen += nRead;
 
+    readMore = needRead;
+    if (readMore < blockSize)
+        readMore = blockSize;
+    else if (readMore % blockSize != 0 &&
+             readMore <= available - (blockSize - readMore % blockSize))
+        readMore += blockSize - readMore % blockSize;
+    if (readMore > available)
+        readMore = available;
+
+    remain = LSAPI_GetReqBodyRemain_r(&g_req);
+    if (remain <= 0)
+    {
+        errno = EIO;
+        return -1;
+    }
+    if (readMore > remain)
+        readMore = remain;
+    if ((uintmax_t)readMore > (uintmax_t)SSIZE_MAX)
+        readMore = SSIZE_MAX;
+
+    nRead = LSAPI_ReadReqBody_r(&g_req,
+               s_body.bodyBuf + (size_t)s_body.bodyCurrentLen,
+               (size_t)readMore);
+    if (nRead > 0)
+        s_body.bodyCurrentLen += nRead;
+    else
+    {
+        if (errno == 0)
+            errno = EIO;
+        return -1;
+    }
     return nRead;
 }
 
+
+static VALUE lsapi_getc( VALUE self )
+{
+    unsigned char ch;
+#if RUBY_API_VERSION_CODE < 20700
+    if (rb_safe_level() >= 4 && !OBJ_TAINTED(self))
+    {
+        rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
+    }
+#endif
+    if (createBodyBuf() != 0)
+        raiseBodyError("cannot allocate LSAPI request body buffer");
+    if (isEofBodyBuf())
+        return Qnil;
+    while (s_body.bodyCurrentLen <= s_body.curPos)
+    {
+        if (readBodyBuf(1) <= 0)
+            raiseBodyError("cannot read LSAPI request body");
+    }
+    ch = (unsigned char)s_body.bodyBuf[(size_t)s_body.curPos++];
+    return INT2NUM( ch );
+}
+
 static VALUE lsapi_gets( VALUE self )
 {
     VALUE str;
     const int blkSize = 4096;
-    int n;
+    off_t n;
     char *p = NULL;
     
 #if RUBY_API_VERSION_CODE < 20700
@@ -599,34 +734,37 @@ static VALUE lsapi_gets( VALUE self )
         rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
     }
 #endif
-    if (createBodyBuf() == 1)
-    {
+    if (createBodyBuf() != 0)
+        raiseBodyError("cannot allocate LSAPI request body buffer");
+    if (isEofBodyBuf())
         return Qnil;
-    }   
     
     //comment:
-    while((p = memmem(s_body.bodyBuf + s_body.curPos, s_body.bodyCurrentLen - s_body.curPos, "\n", 1)) == NULL) 
+    while(memchr(s_body.bodyBuf + (size_t)s_body.curPos, '\n',
+                 (size_t)(s_body.bodyCurrentLen - s_body.curPos)) == NULL)
     {
         if (isAllBodyRead() == 1)
             break;
         //read one page and check, then reply
-        readBodyBuf(blkSize);
+        if (readBodyBuf(blkSize) <= 0)
+            raiseBodyError("cannot read LSAPI request body");
     }
     
-    p = memmem(s_body.bodyBuf + s_body.curPos, s_body.bodyCurrentLen - s_body.curPos, "\n", 1);
+    p = memchr(s_body.bodyBuf + (size_t)s_body.curPos, '\n',
+               (size_t)(s_body.bodyCurrentLen - s_body.curPos));
     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 );
+    str = rb_str_buf_new((long)n);
 #if RUBY_API_VERSION_CODE < 20700
     OBJ_TAINT(str);
 #endif
     
     if (n > 0)
     {
-        rb_str_buf_cat( str, s_body.bodyBuf + s_body.curPos, n );
+        rb_str_buf_cat(str, s_body.bodyBuf + (size_t)s_body.curPos, (long)n);
         s_body.curPos += n;
     }
     
@@ -636,9 +774,11 @@ static VALUE lsapi_gets( VALUE self )
 static VALUE lsapi_read(int argc, VALUE *argv, VALUE self)
 {
     VALUE str;
-    int n;
-    int needRead;
-    int nRead;
+    VALUE length = Qnil;
+    VALUE outbuf = Qnil;
+    off_t n;
+    off_t target;
+    int length_given;
     
 #if RUBY_API_VERSION_CODE < 20700
     if (rb_safe_level() >= 4 && !OBJ_TAINTED(self))
@@ -646,54 +786,52 @@ static VALUE lsapi_read(int argc, VALUE *argv, VALUE self)
         rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
     }
 #endif
-    if (createBodyBuf() == 1)
-    {
-        return Qnil;
-    }
+    rb_scan_args(argc, argv, "02", &length, &outbuf);
+    if (createBodyBuf() != 0)
+        raiseBodyError("cannot allocate LSAPI request body buffer");
     
     //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)
+    length_given = argc > 0 && !NIL_P(length);
+    if (!length_given)
         n = s_body.bodyLen - s_body.curPos;
     else
     {
-        n = NUM2INT(argv[0]); //request that length from currentpos
+        long requested = NUM2LONG(length);
+        n = (off_t)requested;
         if (n < 0)
-            return Qnil;
+            rb_raise(rb_eArgError, "negative length %ld given", requested);
         if (n > s_body.bodyLen - s_body.curPos)
-            n = s_body.bodyLen - s_body.curPos;            
+            n = s_body.bodyLen - s_body.curPos;
     }
-    needRead = s_body.curPos + n - s_body.bodyCurrentLen;
-    if (needRead < 0)
-        needRead = 0;
-    
-    str = rb_str_buf_new( n );
+
+    if (!NIL_P(outbuf))
+    {
+        StringValue(outbuf);
+        rb_str_resize(outbuf, 0);
+        str = outbuf;
+    }
+    else
+        str = rb_str_buf_new((long)n);
 #if RUBY_API_VERSION_CODE < 20700
     OBJ_TAINT(str);
 #endif
     if (n == 0)
-        return str;
-    
-    //copy already have part first
-    if (n - needRead != 0)
     {
-        rb_str_buf_cat( str, s_body.bodyBuf + s_body.curPos, n - needRead);
-        s_body.curPos += (n - needRead);
+        if (length_given && NUM2LONG(length) != 0)
+            return Qnil;
+        return str;
     }
-    
-    if (needRead > 0)
+
+    target = s_body.curPos + n;
+    while (s_body.bodyCurrentLen < target)
     {
-        //try to read needRead, but may be less (changed) when read the end of the data
-        nRead = readBodyBuf(needRead);
-        if (nRead > 0)
-        {
-            n = ((nRead < needRead) ? nRead : needRead);
-            rb_str_buf_cat( str, s_body.bodyBuf + s_body.curPos, n );
-            s_body.curPos += n;
-        }
+        if (readBodyBuf(target - s_body.bodyCurrentLen) <= 0)
+            raiseBodyError("cannot read LSAPI request body");
     }
-    
+    rb_str_buf_cat(str, s_body.bodyBuf + (size_t)s_body.curPos, (long)n);
+    s_body.curPos += n;
     return str;
 }
 
@@ -711,6 +849,8 @@ static VALUE lsapi_each(VALUE self)
     while(isEofBodyBuf() != 1)
     {
         str = lsapi_gets(self);
+        if (NIL_P(str))
+            break;
         rb_yield(str);
     }
     return self;
@@ -719,7 +859,9 @@ static VALUE lsapi_each(VALUE self)
 
 static VALUE lsapi_eof(VALUE self)
 {
-    return (LSAPI_GetReqBodyRemain_r( &g_req ) <= 0) ? Qtrue : Qfalse;
+    if (createBodyBuf() != 0)
+        raiseBodyError("cannot allocate LSAPI request body buffer");
+    return isEofBodyBuf() ? Qtrue : Qfalse;
 }
 
 static VALUE lsapi_binmode(VALUE self)
@@ -732,6 +874,11 @@ static VALUE lsapi_isatty(VALUE self)
     return Qfalse;
 }
 
+static VALUE lsapi_isclosed(VALUE self)
+{
+    return Qfalse;
+}
+
 static VALUE lsapi_sync(VALUE self)
 {
     return Qfalse;
@@ -744,21 +891,11 @@ static VALUE lsapi_setsync(VALUE self,VALUE sync)
 
 static VALUE lsapi_close(VALUE self)
 {
-    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?!
+    int active = (g_req.m_reqState != 0);
+    int flushResult = LSAPI_Flush_r( &g_req );
+    resetBodyBuf();
+    if (flushResult == -1 && active)
+        raiseConnectionError("LSAPI response flush failed");
         
     return Qnil;
 }
@@ -783,49 +920,83 @@ static VALUE lsapi_reopen( int argc, VALUE *argv, VALUE self)
     return self;
 }
 
-static void readMaxBodyBufLength()
+static void readMaxBodyBufLength(void)
 {
-    int n;
+    uintmax_t n;
+    uintmax_t multiplier = 1;
+    char *end;
     const char *p = getenv( "LSAPI_MAX_BODYBUF_LENGTH" );
-    if ( p )
+    if (p)
     {
-        n = atoi( p );
-        if (n > 0)
+        //accepts "<n>", "<n>K", "<n>M", with optional spaces and "B" suffix
+        while (*p == ' ')
+            ++p;
+        if (!isdigit((unsigned char)*p))
+            return;
+        errno = 0;
+        n = strtoumax(p, &end, 10);
+        while (*end == ' ')
+            ++end;
+        if (*end == 'M' || *end == 'm')
+            multiplier = 1024 * 1024;
+        else if (*end == 'K' || *end == 'k')
+            multiplier = 1024;
+        if (multiplier != 1)
         {
-            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;
+            ++end;
+            if (*end == 'B' || *end == 'b')
+                ++end;
         }
+        while (*end == ' ')
+            ++end;
+        if (errno == 0 && n > 0 && *end == '\0' &&
+            n <= (uintmax_t)SIZE_MAX / multiplier)
+            MAX_BODYBUF_LENGTH = (size_t)(n * multiplier);
     }
 }
 
-static void readTempFileTemplate()
+static void readTempFileTemplate(void)
 {
     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");
+    size_t len;
+
+    if (p == NULL || *p == '\0')
+        p = "/tmp/lsapi.XXXXXX";
+    len = strlen(p);
+    if (len >= sizeof(sTempFile) ||
+        (len > sizeof(sTempFile) - sizeof(".XXXXXX") &&
+         (len < 6 || memcmp(p + len - 6, "XXXXXX", 6) != 0)))
+    {
+        p = "/tmp/lsapi.XXXXXX";
+        len = strlen(p);
+    }
+    if (len < 6 || memcmp(p + len - 6, "XXXXXX", 6) != 0)
+    {
+        snprintf(sTempFile, sizeof(sTempFile), "%s.XXXXXX", p);
+    }
+    else
+    {
+        snprintf(sTempFile, sizeof(sTempFile), "%s", p);
+    }
 }
 
-static void initBodyBuf()
+static void initBodyBuf(void)
 {
     s_body.bodyBuf = NULL;
     s_body.bodyLen = -1;
     s_body.bodyCurrentLen = 0;
     s_body.curPos = 0;    
+    s_body.isMapped = 0;
 }
-void Init_lsapi()
+void Init_lsapi(void)
 {
     VALUE orig_verbose; 
     char * p;
     int prefork = 0;
-    LSAPI_Init();
+    if (geteuid() == 0)
+        rb_raise(rb_eSecurityError, "ruby-lsapi refuses to run as root");
+    if (LSAPI_Init() == -1)
+        rb_raise(rb_eRuntimeError, "failed to initialize LSAPI");
     initBodyBuf();
     
     readMaxBodyBufLength();
@@ -836,9 +1007,11 @@ void Init_lsapi()
         prefork = 1;
 
 #ifdef rb_thread_select
-    LSAPI_Init_Env_Parameters( rb_thread_select );
+    if (LSAPI_Init_Env_Parameters( rb_thread_select ) == -1)
+        rb_raise(rb_eRuntimeError, "failed to initialize LSAPI environment");
 #else
-    LSAPI_Init_Env_Parameters( select );
+    if (LSAPI_Init_Env_Parameters( select ) == -1)
+        rb_raise(rb_eRuntimeError, "failed to initialize LSAPI environment");
 #endif
     
     s_pid = getpid();
@@ -847,7 +1020,7 @@ void Init_lsapi()
     if ( p )
     {
         if ( chdir( p ) == -1 )
-            perror( "chdir()" );
+            rb_sys_fail( "cannot chdir to RACK_ROOT" );
     }
     if ( p || getenv( "RACK_ENV" ) )
         s_fn_add_env = add_env_rails;
@@ -863,19 +1036,32 @@ void Init_lsapi()
     
     /* tell the garbage collector it is a global variable, do not recycle it. */
     rb_global_variable(&env_copy);
+    /* $stdin/$stdout/$stderr, STDERR and ENV are replaced below; keep the
+       original objects alive.  Ruby <= 2.0 only references its own STDERR
+       through those, yet still writes errors to it when a process exits. */
+    rb_global_variable(&orig_stdin);
+    rb_global_variable(&orig_stdout);
+    rb_global_variable(&orig_stderr);
+    rb_global_variable(&orig_env);
     
-    rb_hash_aset( env_copy,rb_tainted_str_new("GATEWAY_Irewindable_input.rbNTERFACE", 17),
+    rb_hash_aset( env_copy,rb_tainted_str_new("GATEWAY_INTERFACE", 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);
+    /* instances only come from Data_Make_Struct() below */
+    rb_undef_alloc_func(cLSAPI);
+    /* raised when writing the response fails because the client is gone */
+    eLSAPIConnectionError = rb_define_class_under(cLSAPI, "ConnectionError", rb_eIOError);
     rb_define_singleton_method(cLSAPI, "accept", lsapi_s_accept, 0);
-    if (prefork)
+    /* the prefork server only exists when listening on a socket */
+    if (prefork && LSAPI_Is_Listen())
     {
         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_singleton_method(cLSAPI, "postfork_failed", lsapi_s_postfork_failed, 0);
     }
 
     rb_define_method(cLSAPI, "process", lsapi_process, 0 );
@@ -901,7 +1087,7 @@ void Init_lsapi()
     rb_define_method(cLSAPI, "eof", lsapi_eof, 0);
     rb_define_method(cLSAPI, "eof?", lsapi_eof, 0);
     rb_define_method(cLSAPI, "close", lsapi_close, 0);
-    /* rb_define_method(cLSAPI, "closed?", lsapi_closed, 0); */
+    rb_define_method(cLSAPI, "closed?", lsapi_isclosed, 0);
     rb_define_method(cLSAPI, "binmode", lsapi_binmode, 0);
     rb_define_method(cLSAPI, "isatty", lsapi_isatty, 0);
     rb_define_method(cLSAPI, "tty?", lsapi_isatty, 0);
@@ -912,6 +1098,7 @@ void Init_lsapi()
     
     s_req = Data_Make_Struct( cLSAPI, lsapi_data, lsapi_mark, free, s_req_data );
     s_req_data->req = &g_req;
+    s_req_data->env = Qnil;
     s_req_data->fn_write = LSAPI_Write_r;
     rb_stdin = rb_stdout = s_req;
     
@@ -923,6 +1110,7 @@ void Init_lsapi()
     
     s_req_stderr = Data_Make_Struct( cLSAPI, lsapi_data, lsapi_mark, free, s_stderr_data );
     s_stderr_data->req = &g_req;
+    s_stderr_data->env = Qnil;
     s_stderr_data->fn_write = LSAPI_Write_Stderr_r;
     rb_stderr = s_req_stderr;
     rb_global_variable(&s_req_stderr );
@@ -932,6 +1120,8 @@ void Init_lsapi()
     ruby_verbose = Qnil;
     
     lsapi_env = rb_hash_new();
+    s_req_data->env = lsapi_env;
+    s_stderr_data->env = lsapi_env;
     clear_env();
     /* redefine ENV using a hash table, should be faster than char **environment */
     rb_define_global_const("ENV", lsapi_env);
@@ -942,4 +1132,3 @@ void Init_lsapi()
     
     return;
 }
-