RubyGems - ruby-lsapi - Versions diffs - 4.1 → 5.1 - Mend

ruby-lsapi 4.1 → 5.1

Files changed (8) hide show

checksums.yaml CHANGED

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ZTBmYTY2NTdiZDk3NjAxNTViYmExOTc4ZDU5ZjJhYjk1MmFmNjhiZA==
-  data.tar.gz: !binary |-
-    YmRkNDNhMGZiMmI5Y2I2YjQ0M2Q4OTkzZWVhMjRkMmFmZjA4ZDFlYQ==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    NTg2NGQ5Zjc1NWUyYTExNDUzMTYzN2VhODAyMDI4N2Y0MDFhMTBiMThkMWNm
-    MWU3NDY0Njg4MzcxZDUyYmYzYjJjMjIyYTUxNGU4YTUyOGQ1ZDIxZDg1YWJh
-    YjZlNDJlNTJhMWJkMzZiOWVjMmE2ODQ2ZGNmMTkzMzk1MDRhMDg=
-  data.tar.gz: !binary |-
-    MzBmZDNhMmY5NGQ3NWY0NmJmMDIyMTgzNTUyMDBhZDczMzM2Y2MwY2I5YzAx
-    NGYxN2M0OWEyYTQ1YjYzNTEwNzlmNGQ3ZGY4ZDU1MGM3MTQ2NThlZDkwODBi
-    MjExZWRkOWIxZTI1NGVjMWEwMDNmYzBkNTBjMTBhNmFlZTc5ZTM=
+SHA256:
+  metadata.gz: 665d989d50ec0e54915439997a1a09c0eb77c6bfdc0e1bf86dc96096b8eaab4a
+  data.tar.gz: 0fc93aa398f8f0bf7ef5b566cbd0504f509d6b3f80eb6a1532f719ab1b296f51
+SHA512:
+  metadata.gz: 4ad0661c05da99577c6a8a0974a49e5621c250b498122b6b8acb045dc1076a1e8413f65af66c3b3c78c169b28ab2180ff72db08339c8f8311059c8086223bfbd
+  data.tar.gz: facafedc4aa6c30e1f7007188d743b1a47c919eef452a17119065e0ce47bee4be551fc017521de61cf9685c901494e042a254216c663ca88ff088bdff206d636

data/ext/lsapi/extconf.rb CHANGED

@@ -6,4 +6,7 @@ end
 if RUBY_VERSION =~ /1.9/ then
     $CPPFLAGS += " -DRUBY_19"
 end
+if RUBY_VERSION =~ /2/ then
+    $CPPFLAGS += " -DRUBY_2"
+end
 create_makefile( "lsapi" )

data/ext/lsapi/lsapidef.h CHANGED

@@ -1,21 +1,21 @@
 /*
-Copyright (c) 2005, 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,16 +27,9 @@ 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.
 */
-/***************************************************************************
-    $Id: lsapidef.h,v 1.17 2012/12/01 19:23:31 gwang Exp $
-                         -------------------
-    begin                : Thu Feb 10 2005
-    author               : George Wang
-    email                : gwang@litespeedtech.com
- ***************************************************************************/
 #ifndef  _LSAPIDEF_H_
 #define  _LSAPIDEF_H_
@@ -83,7 +76,7 @@ enum
 /* Values for m_flag in lsapi_packet_header */
 #define LSAPI_ENDIAN_LITTLE         0
-#define LSAPI_ENDIAN_BIG            1
+#define LSAPI_ENDIAN_BIG            1
 #define LSAPI_ENDIAN_BIT            1
 #if defined(__i386__)||defined( __x86_64 )||defined( __x86_64__ )
@@ -126,7 +119,7 @@ struct lsapi_packet_header
 /*
     LSAPI request header packet
     1. struct lsapi_req_header
     2. struct lsapi_http_header_index
     3. lsapi_header_offset * unknownHeaders
@@ -137,7 +130,7 @@ struct lsapi_packet_header
 struct lsapi_req_header
 {
     struct lsapi_packet_header m_pktHeader;
     int32_t m_httpHeaderLen;
     int32_t m_reqBodyLen;
     int32_t m_scriptFileOff;   /* path to the script file. */
@@ -151,11 +144,11 @@ struct lsapi_req_header
 struct lsapi_http_header_index
-{
-    int16_t m_headerLen[H_TRANSFER_ENCODING+1];
+{
+    uint16_t m_headerLen[H_TRANSFER_ENCODING+1];
     int32_t m_headerOff[H_TRANSFER_ENCODING+1];
-} ;
+} ;
 struct lsapi_header_offset
 {
     int32_t nameOff;

data/ext/lsapi/lsapilib.c CHANGED

@@ -1,21 +1,22 @@
+//#define LSAPI_DEBUG
 /*
-Copyright (c) 2005, 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,27 +28,21 @@ 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.
 */
-/***************************************************************************
-                          lsapilib.c  -  description
-                             -------------------
-    begin                : Mon Feb 21 2005
-    copyright            : (C) 2005 by George Wang
-    email                : gwang@litespeedtech.com
- ***************************************************************************/
 #include <ctype.h>
 #include <dlfcn.h>
 #include <errno.h>
 #include <fcntl.h>
+#include <limits.h>
 #include <sys/stat.h>
+#include <sched.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <stdio.h>
+#include <stdarg.h>
 #include <string.h>
 #include <sys/mman.h>
 #include <sys/resource.h>
@@ -102,25 +97,70 @@ typedef struct lsapi_MD5Context lsapi_MD5_CTX;
 #define LSAPI_ST_REQ_BODY       2
 #define LSAPI_ST_RESP_HEADER    4
 #define LSAPI_ST_RESP_BODY      8
+#define LSAPI_ST_BACKGROUND     16
 #define LSAPI_RESP_BUF_SIZE     8192
 #define LSAPI_INIT_RESP_HEADER_LEN 4096
+enum
+{
+    LSAPI_STATE_IDLE,
+    LSAPI_STATE_CONNECTED,
+    LSAPI_STATE_ACCEPTING,
+};
+typedef struct lsapi_child_status
+{
+    int     m_pid;
+    long    m_tmStart;
+    volatile short   m_iKillSent;
+    volatile char    m_inProcess;
+    volatile char    m_state;
+    volatile int     m_iReqCounter;
+    volatile long    m_tmWaitBegin;
+    volatile long    m_tmReqBegin;
+    volatile long    m_tmLastCheckPoint;
+}
+lsapi_child_status;
+static lsapi_child_status * s_worker_status = NULL;
 static int g_inited = 0;
 static int g_running = 1;
 static int s_ppid;
+static int s_restored_ppid = 0;
+static int s_pid = 0;
 static int s_slow_req_msecs = 0;
 static int s_keepListener = 0;
 static int s_dump_debug_info = 0;
+static int s_pid_dump_debug_info = 0;
+static int s_req_processed = 0;
+static int s_skip_write = 0;
+static int (*pthread_atfork_func)(void (*prepare)(void), void (*parent)(void),
+                                  void (*child)(void)) = NULL;
-LSAPI_Request g_req = { -1, -1 };
+static int *s_busy_workers = NULL;
+static int *s_accepting_workers = NULL;
+static int *s_global_counter = &s_req_processed;
+static int s_max_busy_workers = -1;
+static char *s_stderr_log_path = NULL;
+static int s_stderr_is_pipe = 0;
+static int s_ignore_pid = -1;
+static size_t s_total_pages = 1;
+static size_t s_min_avail_pages = 256 * 1024;
+static size_t *s_avail_pages = &s_total_pages;
-static char         s_pSecret[24];
+LSAPI_Request g_req =
+{ .m_fdListen = -1, .m_fd = -1 };
+static char         s_secret[24];
+static LSAPI_On_Timer_pf s_proc_group_timer_cb = NULL;
 void Flush_RespBuf_r( LSAPI_Request * pReq );
+static int lsapi_reopen_stderr(const char *p);
 static const char *CGI_HEADERS[H_TRANSFER_ENCODING+1] =
 {
@@ -142,7 +182,7 @@ static const char *CGI_HEADERS[H_TRANSFER_ENCODING+1] =
     "HTTP_VIA",
     "HTTP_TRANSFER_ENCODING"
 };
 static int CGI_HEADER_LEN[H_TRANSFER_ENCODING+1] =
 {    11, 19, 20, 20, 18, 15, 12, 14, 11, 12, 9, 11, 12, 15, 18,
      22, 13, 18, 13, 24, 15, 10, 20, 8, 22 };
@@ -173,10 +213,102 @@ static int HTTP_HEADER_LEN[H_TRANSFER_ENCODING+1] =
 {   6, 14, 15, 15, 13, 10, 12, 14, 6, 7, 4, 6, 7, 10, //user-agent
     13,17, 8, 13, 8, 19, 10, 5, 15, 3, 17
 };
+static const char *s_log_level_names[8] =
+{
+    "", "DEBUG","INFO", "NOTICE", "WARN", "ERROR", "CRIT", "FATAL"
+};
+void LSAPI_Log(int flag, const char * fmt, ...)
+{
+    char buf[1024];
+    char *p = buf;
+    if ((flag & LSAPI_LOG_TIMESTAMP_BITS)
+        && !(s_stderr_is_pipe))
+    {
+        struct timeval  tv;
+        struct tm       tm;
+        gettimeofday(&tv, NULL);
+        localtime_r(&tv.tv_sec, &tm);
+        if (flag & LSAPI_LOG_TIMESTAMP_FULL)
+        {
+            p += snprintf(p, 1024, "%04d-%02d-%02d %02d:%02d:%02d.%06d ",
+                tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
+                tm.tm_hour, tm.tm_min, tm.tm_sec, (int)tv.tv_usec);
+        }
+        else if (flag & LSAPI_LOG_TIMESTAMP_HMS)
+        {
+            p += snprintf(p, 1024, "%02d:%02d:%02d ",
+                tm.tm_hour, tm.tm_min, tm.tm_sec);
+        }
+    }
+    int level = flag & LSAPI_LOG_LEVEL_BITS;
+    if (level && level <= LSAPI_LOG_FLAG_FATAL)
+    {
+        p += snprintf(p, 100, "[%s] ", s_log_level_names[level]);
+    }
+    if (flag & LSAPI_LOG_PID)
+    {
+        p += snprintf(p, 100, "[UID:%d][%d] ", getuid(), s_pid);
+    }
+    if (p > buf)
+        fprintf(stderr, "%.*s", (int)(p - buf), buf);
+    va_list ap;
+    va_start(ap, fmt);
+    vfprintf(stderr, fmt, ap);
+    va_end(ap);
+}
+#ifdef LSAPI_DEBUG
+#define DBGLOG_FLAG (LSAPI_LOG_TIMESTAMP_FULL|LSAPI_LOG_FLAG_DEBUG|LSAPI_LOG_PID)
+#define lsapi_dbg(...)   LSAPI_Log(DBGLOG_FLAG, __VA_ARGS__)
+#else
+#define lsapi_dbg(...)
+#endif
+#define lsapi_log(...)  LSAPI_Log(LSAPI_LOG_TIMESTAMP_FULL|LSAPI_LOG_PID, __VA_ARGS__)
+void lsapi_perror(const char * pMessage, int err_no)
+{
+    lsapi_log("%s, errno: %d (%s)\n", pMessage, err_no, strerror(err_no));
+}
+static int lsapi_parent_dead()
+{
+    // Return non-zero if the parent is dead.  0 if still alive.
+    if (!s_ppid) {
+        // not checking, so not dead
+        return(0);
+    }
+    if (s_restored_ppid) {
+        if (kill(s_restored_ppid,0) == -1) {
+            if (errno == EPERM) {
+                return(0); // no permission, but it's still there.
+            }
+            return(1); // Dead
+        }
+        return(0); // it worked, so it's not dead
+    }
+    return(s_ppid != getppid());
+}
 static void lsapi_sigpipe( int sig )
 {
 }
 static void lsapi_siguser1( int sig )
 {
     g_running = 0;
@@ -185,7 +317,7 @@ static void lsapi_siguser1( int sig )
 #ifndef sighandler_t
 typedef void (*sighandler_t)(int);
 #endif
 static void lsapi_signal(int signo, sighandler_t handler)
 {
     struct sigaction sa;
@@ -203,12 +335,12 @@ static void lsapi_signal(int signo, sighandler_t handler)
 static int s_enable_core_dump = 0;
-static void lsapi_enable_core_dump()
+static void lsapi_enable_core_dump(void)
 {
 #if defined(__FreeBSD__ ) || defined(__NetBSD__) || defined(__OpenBSD__) \
     || defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)
     int  mib[2];
-    size_t len;
+    size_t len;
     len = 2;
     if ( sysctlnametomib("kern.sugid_coredump", mib, &len) == 0 )
@@ -219,7 +351,7 @@ static void lsapi_enable_core_dump()
                     "core dump may not be available!");
     }
 #endif
 #if defined(linux) || defined(__linux) || defined(__linux__) || defined(__gnu_linux__)
@@ -230,7 +362,6 @@ static void lsapi_enable_core_dump()
 }
 static inline void lsapi_buildPacketHeader( struct lsapi_packet_header * pHeader,
                                 char type, int len )
 {
@@ -241,6 +372,7 @@ static inline void lsapi_buildPacketHeader( struct lsapi_packet_header * pHeader
     pHeader->m_packetLen.m_iLen = len;
 }
 static  int lsapi_set_nblock( int fd, int nonblock )
 {
     int val = fcntl( fd, F_GETFL, 0 );
@@ -261,6 +393,7 @@ static  int lsapi_set_nblock( int fd, int nonblock )
     return 0;
 }
 static int lsapi_close( int fd )
 {
     int ret;
@@ -273,6 +406,20 @@ static int lsapi_close( int fd )
     }
 }
+static void lsapi_close_connection(LSAPI_Request *pReq)
+{
+    if (pReq->m_fd == -1)
+        return;
+    lsapi_close(pReq->m_fd);
+    pReq->m_fd = -1;
+    if (s_busy_workers)
+        __sync_fetch_and_sub(s_busy_workers, 1);
+    if (s_worker_status)
+        __sync_lock_test_and_set(&s_worker_status->m_state, LSAPI_STATE_IDLE);
+}
 static inline ssize_t lsapi_read( int fd, void * pBuf, size_t len )
 {
     ssize_t ret;
@@ -285,6 +432,7 @@ static inline ssize_t lsapi_read( int fd, void * pBuf, size_t len )
     }
 }
 /*
 static int lsapi_write( int fd, const void * pBuf, int len )
 {
@@ -307,11 +455,16 @@ static int lsapi_write( int fd, const void * pBuf, int len )
 }
 */
 static int lsapi_writev( int fd, struct iovec ** pVec, int count, int totalLen )
 {
     int ret;
     int left = totalLen;
     int n = count;
+    if (s_skip_write)
+        return totalLen;
     while(( left > 0 )&&g_running )
     {
         ret = writev( fd, *pVec, n );
@@ -351,6 +504,7 @@ static int lsapi_writev( int fd, struct iovec ** pVec, int count, int totalLen )
     return totalLen - left;
 }
 /*
 static int getTotalLen( struct iovec * pVec, int count )
 {
@@ -365,6 +519,7 @@ static int getTotalLen( struct iovec * pVec, int count )
 }
 */
 static inline int allocateBuf( LSAPI_Request * pReq, int size )
 {
     char * pBuf = (char *)realloc( pReq->m_pReqBuf, size );
@@ -392,6 +547,7 @@ static int allocateIovec( LSAPI_Request * pReq, int n )
     return 0;
 }
 static int allocateRespHeaderBuf( LSAPI_Request * pReq, int size )
 {
     char * p = (char *)realloc( pReq->m_pRespHeaderBuf, size );
@@ -423,11 +579,12 @@ static inline int verifyHeader( struct lsapi_packet_header * pHeader, char pktTy
     return pHeader->m_packetLen.m_iLen;
 }
 static int allocateEnvList( struct LSAPI_key_value_pair ** pEnvList,
                         int *curSize, int newSize )
 {
     struct LSAPI_key_value_pair * pBuf;
-        if ( *curSize >= newSize )
+    if ( *curSize >= newSize )
         return 0;
     if ( newSize > 8192 )
         return -1;
@@ -444,6 +601,7 @@ static int allocateEnvList( struct LSAPI_key_value_pair ** pEnvList,
 }
 static inline int isPipe( int fd )
 {
     char        achPeer[128];
@@ -455,6 +613,7 @@ static inline int isPipe( int fd )
         return 1;
 }
 static int parseEnv( struct LSAPI_key_value_pair * pEnvList, int count,
             char **pBegin, char * pEnd )
 {
@@ -491,6 +650,7 @@ static int parseEnv( struct LSAPI_key_value_pair * pEnvList, int count,
     return 0;
 }
 static inline void swapIntEndian( int * pInteger )
 {
     char * p = (char *)pInteger;
@@ -501,9 +661,10 @@ static inline void swapIntEndian( int * pInteger )
     b = p[1];
     p[1] = p[2];
     p[2] = b;
 }
 static inline void fixEndian( LSAPI_Request * pReq )
 {
     struct lsapi_req_header *p= pReq->m_pHeader;
@@ -518,6 +679,7 @@ static inline void fixEndian( LSAPI_Request * pReq )
     swapIntEndian( &p->m_cntSpecialEnv );
 }
 static void fixHeaderIndexEndian( LSAPI_Request * pReq )
 {
     int i;
@@ -549,6 +711,40 @@ static void fixHeaderIndexEndian( LSAPI_Request * pReq )
     }
 }
+static int validateHeaders( LSAPI_Request * pReq )
+{
+    int totalLen = pReq->m_pHeader->m_httpHeaderLen;
+    int i;
+    for(i = 0; i < H_TRANSFER_ENCODING; ++i)
+    {
+        if ( pReq->m_pHeaderIndex->m_headerOff[i] )
+        {
+            if (pReq->m_pHeaderIndex->m_headerOff[i] > totalLen
+                || pReq->m_pHeaderIndex->m_headerLen[i]
+                    + pReq->m_pHeaderIndex->m_headerOff[i] > totalLen)
+                return -1;
+        }
+    }
+    if (pReq->m_pHeader->m_cntUnknownHeaders > 0)
+    {
+        struct lsapi_header_offset * pCur, *pEnd;
+        pCur = pReq->m_pUnknownHeader;
+        pEnd = pCur + pReq->m_pHeader->m_cntUnknownHeaders;
+        while( pCur < pEnd )
+        {
+            if (pCur->nameOff > totalLen
+                || pCur->nameOff + pCur->nameLen > totalLen
+                || pCur->valueOff > totalLen
+                || pCur->valueOff + pCur->valueLen > totalLen)
+                return -1;
+            ++pCur;
+        }
+    }
+    return 0;
+}
 static uid_t s_uid = 0;
 static uid_t s_defaultUid;  //web server need set this
 static gid_t s_defaultGid;
@@ -570,23 +766,23 @@ static int (*fp_lve_destroy)(struct liblve *) = NULL;
 static int (*fp_lve_enter)(struct liblve *, uint32_t, int32_t, int32_t, uint32_t *) = NULL;
 static int (*fp_lve_leave)(struct liblve *, uint32_t *) = NULL;
 static int (*fp_lve_jail)( struct passwd *, char *) = NULL;
-static int lsapi_load_lve_lib()
+static int lsapi_load_lve_lib(void)
 {
-    s_liblve = dlopen("liblve.so.0", RTLD_LAZY);
+    s_liblve = dlopen("liblve.so.0", RTLD_NOW | RTLD_GLOBAL);
     if (s_liblve)
     {
         fp_lve_is_available = dlsym(s_liblve, "lve_is_available");
-        if (dlerror() == NULL)
+        if (dlerror() == NULL)
         {
             if ( !(*fp_lve_is_available)() )
             {
                 int uid = getuid();
                 if ( uid )
                 {
-                    setreuid( s_uid, uid );
+                    if (setreuid( s_uid, uid )) {};
                     if ( !(*fp_lve_is_available)() )
                         s_enable_lve = 0;
-                    setreuid( uid, s_uid );
+                    if (setreuid( uid, s_uid )) {};
                 }
             }
         }
@@ -598,11 +794,12 @@ static int lsapi_load_lve_lib()
     return (s_liblve)? 0 : -1;
 }
-static int init_lve_ex()
+static int init_lve_ex(void)
 {
     int rc;
     if ( !s_liblve )
-        return -1;
+        return -1;
     fp_lve_instance_init = dlsym(s_liblve, "lve_instance_init");
     fp_lve_destroy = dlsym(s_liblve, "lve_destroy");
     fp_lve_enter = dlsym(s_liblve, "lve_enter");
@@ -610,13 +807,13 @@ static int init_lve_ex()
     if ( s_enable_lve >= LSAPI_CAGEFS_ENABLED )
         fp_lve_jail = dlsym(s_liblve, "jail" );
-    if ( s_lve == NULL )
+    if ( s_lve == NULL )
     {
         rc = (*fp_lve_instance_init)(NULL);
         s_lve = malloc(rc);
     }
     rc = (*fp_lve_instance_init)(s_lve);
-    if (rc != 0)
+    if (rc != 0)
     {
         perror( "LSAPI: Unable to initialize LVE" );
         free( s_lve );
@@ -624,7 +821,7 @@ static int init_lve_ex()
         return -1;
     }
     return 0;
 }
 #endif
@@ -637,32 +834,32 @@ static int readSecret( const char * pSecretFile )
     int fd = open( pSecretFile, O_RDONLY , 0600 );
     if ( fd == -1 )
     {
-        fprintf( stderr, "LSAPI: failed to open secret file: %s!\n", pSecretFile );
+        lsapi_log("LSAPI: failed to open secret file: %s!\n", pSecretFile );
         return -1;
     }
     if ( fstat( fd, &st ) == -1 )
     {
-        fprintf( stderr, "LSAPI: failed to check state of file: %s!\n", pSecretFile );
+        lsapi_log("LSAPI: failed to check state of file: %s!\n", pSecretFile );
         close( fd );
         return -1;
     }
 /*
     if ( st.st_uid != s_uid )
     {
-        fprintf( stderr, "LSAPI: file owner check failure: %s!\n", pSecretFile );
+        lsapi_log("LSAPI: file owner check failure: %s!\n", pSecretFile );
         close( fd );
         return -1;
     }
 */
     if ( st.st_mode & 0077 )
     {
-        fprintf( stderr, "LSAPI: file permission check failure: %s\n", pSecretFile );
+        lsapi_log("LSAPI: file permission check failure: %s\n", pSecretFile );
         close( fd );
         return -1;
     }
-    if ( read( fd, s_pSecret, 16 ) < 16 )
+    if ( read( fd, s_secret, 16 ) < 16 )
     {
-        fprintf( stderr, "LSAPI: failed to read secret from secret file: %s\n", pSecretFile );
+        lsapi_log("LSAPI: failed to read secret from secret file: %s\n", pSecretFile );
         close( fd );
         return -1;
     }
@@ -670,55 +867,56 @@ static int readSecret( const char * pSecretFile )
     return 0;
 }
-static int lsapi_initSuEXEC()
-{
-    int i;
-    struct passwd * pw;
-    pw = getpwnam( "nobody" );
-    s_defaultUid = pw->pw_uid;
-    s_defaultGid = pw->pw_gid;
-    if ( s_uid == 0 )
-    {
-        const char * p = getenv( "LSAPI_DEFAULT_UID" );
-        if ( p )
-        {
-            i = atoi( p );
-            if ( i > 0 )
-                s_defaultUid = i;
-        }
-        p = getenv( "LSAPI_DEFAULT_GID" );
-        if ( p )
-        {
-            i = atoi( p );
-            if ( i > 0 )
-                s_defaultGid = i;
-        }
-        p = getenv( "LSAPI_SECRET" );
-        if (( !p )||( readSecret(p) == -1 ))
-                return -1;
-    }
-    return 0;
-}
-int LSAPI_is_suEXEC_Daemon()
+int LSAPI_is_suEXEC_Daemon(void)
 {
-    if (( !s_uid )&&( s_pSecret[0] ))
+    if (( !s_uid )&&( s_secret[0] ))
         return 1;
     else
         return 0;
 }
 static int LSAPI_perror_r( LSAPI_Request * pReq, const char * pErr1, const char *pErr2 )
 {
-    char achError[1024];
-    int n = snprintf(achError, 1024, "%s:%s: %s\n", pErr1, (pErr2)?pErr2:"", strerror( errno ) );
+    char achError[4096];
+    int n = snprintf(achError, sizeof(achError), "[UID:%d][%d] %s:%s: %s\n",
+                     getuid(), getpid(),
+                     pErr1, (pErr2)?pErr2:"", strerror(errno));
+    if (n > (int)sizeof(achError))
+        n = sizeof(achError);
     if ( pReq )
         LSAPI_Write_Stderr_r( pReq, achError, n );
     else
-        write( STDERR_FILENO, achError, n );
+        if (write( STDERR_FILENO, achError, n )) {};
     return 0;
 }
+static int lsapi_lve_error( LSAPI_Request * pReq )
+{
+    static const char * headers[] =
+    {
+        "Cache-Control: private, no-cache, no-store, must-revalidate, max-age=0",
+        "Pragma: no-cache",
+        "Retry-After: 60",
+        "Content-Type: text/html",
+        NULL
+    };
+    static const char achBody[] =
+        "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n"
+        "<HTML><HEAD>\n<TITLE>508 Resource Limit Is Reached</TITLE>\n"
+        "</HEAD><BODY>\n" "<H1>Resource Limit Is Reached</H1>\n"
+        "The website is temporarily unable to service your request as it exceeded resource limit.\n"
+        "Please try again later.\n"
+        "<HR>\n"
+        "</BODY></HTML>\n";
+    LSAPI_ErrResponse_r( pReq, 508, headers, achBody, sizeof( achBody ) - 1 );
+    return 0;
+}
 static int lsapi_enterLVE( LSAPI_Request * pReq, uid_t uid )
 {
 #if defined(linux) || defined(__linux) || defined(__linux__) || defined(__gnu_linux__)
@@ -729,8 +927,9 @@ static int lsapi_enterLVE( LSAPI_Request * pReq, uid_t uid )
         ret = (*fp_lve_enter)(s_lve, uid, -1, -1, &cookie);
         if ( ret < 0 )
         {
-            fprintf( stderr, "Pid (%d): enter LVE (%d) : ressult: %d !\n", getpid(), uid, ret );
+            //lsapi_log("enter LVE (%d) : ressult: %d !\n", uid, ret );
             LSAPI_perror_r(pReq, "LSAPI: lve_enter() failure, reached resource limit.", NULL );
+            lsapi_lve_error( pReq );
             return -1;
         }
     }
@@ -739,6 +938,7 @@ static int lsapi_enterLVE( LSAPI_Request * pReq, uid_t uid )
     return 0;
 }
 static int lsapi_jailLVE( LSAPI_Request * pReq, uid_t uid, struct passwd * pw )
 {
     int ret = 0;
@@ -747,8 +947,8 @@ static int lsapi_jailLVE( LSAPI_Request * pReq, uid_t uid, struct passwd * pw )
     ret = (*fp_lve_jail)( pw, error_msg );
     if ( ret < 0 )
     {
-        fprintf( stderr, "LSAPI (%d): LVE jail(%d) ressult: %d, error: %s !\n",
-                        getpid(), uid, ret, error_msg );
+        lsapi_log("LSAPI: LVE jail(%d) ressult: %d, error: %s !\n",
+                  uid, ret, error_msg );
         LSAPI_perror_r( pReq, "LSAPI: jail() failure.", NULL );
         return -1;
     }
@@ -758,7 +958,7 @@ static int lsapi_jailLVE( LSAPI_Request * pReq, uid_t uid, struct passwd * pw )
 #if defined(linux) || defined(__linux) || defined(__linux__) || defined(__gnu_linux__)
-static int lsapi_initLVE()
+static int lsapi_initLVE(void)
 {
     const char * pEnv;
     if ( (pEnv = getenv( "LSAPI_LVE_ENABLE" ))!= NULL )
@@ -792,7 +992,7 @@ static int setUID_LVE(LSAPI_Request * pReq, uid_t uid, gid_t gid, const char * p
     pw = getpwuid( uid );
 #if defined(linux) || defined(__linux) || defined(__linux__) || defined(__gnu_linux__)
     if ( s_lve )
-    {
+    {
         if( lsapi_enterLVE( pReq, uid ) == -1 )
             return -1;
         if ( pw && fp_lve_jail)
@@ -809,7 +1009,7 @@ static int setUID_LVE(LSAPI_Request * pReq, uid_t uid, gid_t gid, const char * p
         }
     }
 #endif
-    //if ( !uid || !gid )  //do not allow root
+    //if ( !uid || !gid )  //do not allow root
     //{
     //    return -1;
     //}
@@ -865,7 +1065,7 @@ static int setUID_LVE(LSAPI_Request * pReq, uid_t uid, gid_t gid, const char * p
     return 0;
 }
-static int lsapi_suexec_auth( LSAPI_Request *pReq,
+static int lsapi_suexec_auth( LSAPI_Request *pReq,
             char * pAuth, int len, char * pUgid, int ugidLen )
 {
     lsapi_MD5_CTX md5ctx;
@@ -873,7 +1073,7 @@ static int lsapi_suexec_auth( LSAPI_Request *pReq,
     if ( len < 32 )
         return -1;
     memmove( achMD5, pAuth + 16, 16 );
-    memmove( pAuth + 16, s_pSecret, 16 );
+    memmove( pAuth + 16, s_secret, 16 );
     lsapi_MD5Init( &md5ctx );
     lsapi_MD5Update( &md5ctx, (unsigned char *)pAuth, 32 );
     lsapi_MD5Update( &md5ctx, (unsigned char *)pUgid, 8 );
@@ -888,7 +1088,8 @@ static int lsapi_changeUGid( LSAPI_Request * pReq )
 {
     int uid = s_defaultUid;
     int gid = s_defaultGid;
-    const char * pChroot = NULL;
+    const char *pStderrLog;
+    const char *pChroot = NULL;
     struct LSAPI_key_value_pair * pEnv;
     struct LSAPI_key_value_pair * pAuth;
     int i;
@@ -897,7 +1098,7 @@ static int lsapi_changeUGid( LSAPI_Request * pReq )
     //with special ID  0x00
     //authenticate the suEXEC request;
     //first one should be MD5( nonce + lscgid secret )
-    //remember to clear the secret after verification
+    //remember to clear the secret after verification
     //it should be set at the end of special env
     i = pReq->m_pHeader->m_cntSpecialEnv - 1;
     if ( i >= 0 )
@@ -913,29 +1114,29 @@ static int lsapi_changeUGid( LSAPI_Request * pReq )
             {
                 --pReq->m_pHeader->m_cntSpecialEnv;
                 uid = *(uint32_t *)pEnv->pValue;
-                gid = *(((uint32_t *)pEnv->pValue) + 1 );
-                //fprintf( stderr, "LSAPI: SUEXEC_UGID set UID: %d, GID: %d\n", uid, gid );
+                gid = *(((uint32_t *)pEnv->pValue) + 1 );
+                //lsapi_log("LSAPI: SUEXEC_UGID set UID: %d, GID: %d\n", uid, gid );
             }
             else
             {
-                fprintf( stderr, "LSAPI: missing SUEXEC_UGID env, use default user!\n" );
+                lsapi_log("LSAPI: missing SUEXEC_UGID env, use default user!\n" );
                 pEnv = NULL;
             }
             if ( pEnv&& lsapi_suexec_auth( pReq, pAuth->pValue, pAuth->valLen, pEnv->pValue, pEnv->valLen ) == 0 )
             {
-                //read UID, GID from specialEnv
+                //read UID, GID from specialEnv
             }
             else
             {
                 //authentication error
-                fprintf( stderr, "LSAPI: SUEXEC_AUTH authentication failed, use default user!\n" );
+                lsapi_log("LSAPI: SUEXEC_AUTH authentication failed, use default user!\n" );
                 uid = 0;
             }
         }
         else
         {
-            //fprintf( stderr, "LSAPI: no SUEXEC_AUTH env, use default user!\n" );
+            //lsapi_log("LSAPI: no SUEXEC_AUTH env, use default user!\n" );
         }
     }
@@ -952,12 +1153,23 @@ static int lsapi_changeUGid( LSAPI_Request * pReq )
         return -1;
     }
-    s_uid = uid;
+    s_uid = uid;
+    if ( pReq->m_fdListen != -1 )
+    {
+        close( pReq->m_fdListen );
+        pReq->m_fdListen = -1;
+    }
+    pStderrLog = LSAPI_GetEnv_r( pReq, "LSAPI_STDERR_LOG");
+    if (pStderrLog)
+        lsapi_reopen_stderr(pStderrLog);
     return 0;
 }
 static int parseContentLenFromHeader(LSAPI_Request * pReq)
 {
     const char * pContentLen = LSAPI_GetHeader_r( pReq, H_CONTENT_LENGTH );
@@ -995,12 +1207,23 @@ static int parseRequest( LSAPI_Request * pReq, int totalLen )
     if ( parseEnv( pReq->m_pEnvList, pReq->m_pHeader->m_cntEnv,
                 &pBegin, pEnd ) == -1 )
         return -1;
+    if (pReq->m_pHeader->m_scriptFileOff < 0
+        || pReq->m_pHeader->m_scriptFileOff >= totalLen
+        || pReq->m_pHeader->m_scriptNameOff < 0
+        || pReq->m_pHeader->m_scriptNameOff >= totalLen
+        || pReq->m_pHeader->m_queryStringOff < 0
+        || pReq->m_pHeader->m_queryStringOff >= totalLen
+        || pReq->m_pHeader->m_requestMethodOff < 0
+        || pReq->m_pHeader->m_requestMethodOff >= totalLen)
+    {
+        lsapi_log("Bad request header - ERROR#1\n");
+        return -1;
+    }
     pReq->m_pScriptFile     = pReq->m_pReqBuf + pReq->m_pHeader->m_scriptFileOff;
     pReq->m_pScriptName     = pReq->m_pReqBuf + pReq->m_pHeader->m_scriptNameOff;
     pReq->m_pQueryString    = pReq->m_pReqBuf + pReq->m_pHeader->m_queryStringOff;
     pReq->m_pRequestMethod  = pReq->m_pReqBuf + pReq->m_pHeader->m_requestMethodOff;
     pBegin = pReq->m_pReqBuf + (( pBegin - pReq->m_pReqBuf + 7 ) & (~0x7));
     pReq->m_pHeaderIndex = ( struct lsapi_http_header_index * )pBegin;
     pBegin += sizeof( struct lsapi_http_header_index );
@@ -1013,36 +1236,94 @@ static int parseRequest( LSAPI_Request * pReq, int totalLen )
     pBegin += pReq->m_pHeader->m_httpHeaderLen;
     if ( pBegin != pEnd )
     {
-        fprintf( stderr, "%d: request header does match total size, total: %d, real: %ld\n", getpid(), totalLen,
-                    pBegin - pReq->m_pReqBuf );
+        lsapi_log("Request header does match total size, total: %d, "
+                 "real: %ld\n", totalLen, pBegin - pReq->m_pReqBuf );
         return -1;
     }
     if ( shouldFixEndian )
     {
         fixHeaderIndexEndian( pReq );
     }
+    if (validateHeaders(pReq) == -1)
+    {
+        lsapi_log("Bad request header - ERROR#2\n");
+        return -1;
+    }
     pReq->m_reqBodyLen = pReq->m_pHeader->m_reqBodyLen;
     if ( pReq->m_reqBodyLen == -2 )
     {
         parseContentLenFromHeader(pReq);
     }
     return 0;
 }
 //OPTIMIZATION
-static int s_accept_notify = 0;
+static char s_accept_notify = 0;
+static char s_schedule_notify = 0;
+static char s_notify_scheduled = 0;
+static char s_notified_pid = 0;
-static struct lsapi_packet_header ack = {'L', 'S',
+static struct lsapi_packet_header s_ack = {'L', 'S',
                 LSAPI_REQ_RECEIVED, LSAPI_ENDIAN, {LSAPI_PACKET_HEADER_LEN} };
-static inline int notify_req_received( int fd )
+static struct lsapi_packet_header s_conn_close_pkt = {'L', 'S',
+                LSAPI_CONN_CLOSE, LSAPI_ENDIAN, {LSAPI_PACKET_HEADER_LEN} };
+static inline int send_notification_pkt( int fd, struct lsapi_packet_header *pkt )
 {
-    if ( write( fd, &ack, LSAPI_PACKET_HEADER_LEN )
-                < LSAPI_PACKET_HEADER_LEN )
+    if ( write( fd, pkt, LSAPI_PACKET_HEADER_LEN ) < LSAPI_PACKET_HEADER_LEN )
         return -1;
     return 0;
 }
+static inline int send_req_received_notification( int fd )
+{
+    return send_notification_pkt(fd, &s_ack);
+}
+static inline int send_conn_close_notification( int fd )
+{
+    return send_notification_pkt(fd, &s_conn_close_pkt);
+}
+//static void lsapi_sigalarm( int sig )
+//{
+//    if ( s_notify_scheduled )
+//    {
+//        s_notify_scheduled = 0;
+//        if ( g_req.m_fd != -1 )
+//            write_req_received_notification( g_req.m_fd );
+//    }
+//}
+static inline int lsapi_schedule_notify(void)
+{
+    if ( !s_notify_scheduled )
+    {
+        alarm( 2 );
+        s_notify_scheduled = 1;
+    }
+    return 0;
+}
+static inline int notify_req_received( int fd )
+{
+    if ( s_schedule_notify )
+        return lsapi_schedule_notify();
+    return send_req_received_notification( fd );
+}
 static inline int lsapi_notify_pid( int fd )
 {
     char achBuf[16];
@@ -1050,12 +1331,13 @@ static inline int lsapi_notify_pid( int fd )
                         8 + LSAPI_PACKET_HEADER_LEN );
     memmove( &achBuf[8], "\0PID", 4 );
     *((int *)&achBuf[12]) = getpid();
     if ( write( fd, achBuf, 16 ) < 16 )
         return -1;
     return 0;
 }
 static char s_conn_key_packet[16];
 static inline int init_conn_key( int fd )
 {
@@ -1074,10 +1356,11 @@ static inline int init_conn_key( int fd )
                 < LSAPI_PACKET_HEADER_LEN+8 )
         return -1;
     return 0;
 }
 static int readReq( LSAPI_Request * pReq )
 {
     int len;
@@ -1102,12 +1385,12 @@ static int readReq( LSAPI_Request * pReq )
     packetLen = verifyHeader( &pReq->m_pHeader->m_pktHeader, LSAPI_BEGIN_REQUEST );
     if ( packetLen < 0 )
     {
-        fprintf( stderr, "%d: packetLen < 0\n", getpid() );
+        lsapi_log("packetLen < 0\n");
         return -1;
     }
     if ( packetLen > LSAPI_MAX_HEADER_LEN )
     {
-        fprintf( stderr, "%d: packetLen > %d\n", getpid(), LSAPI_MAX_HEADER_LEN );
+        lsapi_log("packetLen > %d\n", LSAPI_MAX_HEADER_LEN );
         return -1;
     }
@@ -1125,59 +1408,80 @@ static int readReq( LSAPI_Request * pReq )
     }
     if ( parseRequest( pReq, packetLen ) < 0 )
     {
-        fprintf( stderr, "%d: parseRequest error\n", getpid() );
+        lsapi_log("ParseRequest error\n");
         return -1;
     }
+    pReq->m_reqState = LSAPI_ST_REQ_BODY | LSAPI_ST_RESP_HEADER;
     if ( !s_uid )
+    {
         if ( lsapi_changeUGid( pReq ) )
             return -1;
+        memset(s_secret, 0, sizeof(s_secret));
+    }
     pReq->m_bufProcessed = packetLen;
-    pReq->m_reqState = LSAPI_ST_REQ_BODY | LSAPI_ST_RESP_HEADER;
     //OPTIMIZATION
-    if ( !s_accept_notify )
+    if ( !s_accept_notify && !s_notified_pid )
         return notify_req_received( pReq->m_fd );
     else
+    {
+        s_notified_pid = 0;
         return 0;
+    }
 }
 int LSAPI_Init(void)
 {
     if ( !g_inited )
     {
         s_uid = geteuid();
-        s_pSecret[0] = 0;
+        s_secret[0] = 0;
         lsapi_signal(SIGPIPE, lsapi_sigpipe);
         lsapi_signal(SIGUSR1, lsapi_siguser1);
 #if defined(SIGXFSZ) && defined(SIG_IGN)
         signal(SIGXFSZ, SIG_IGN);
 #endif
-        /* let STDOUT function as STDERR,
+        /* let STDOUT function as STDERR,
            just in case writing to STDOUT directly */
-        dup2( 2, 1 );
+        dup2( 2, 1 );
         if ( LSAPI_InitRequest( &g_req, LSAPI_SOCK_FILENO ) == -1 )
             return -1;
         g_inited = 1;
         s_ppid = getppid();
+        void *pthread_lib = dlopen("libpthread.so", RTLD_LAZY);
+        if (pthread_lib)
+            pthread_atfork_func = dlsym(pthread_lib, "pthread_atfork");
     }
     return 0;
 }
 void LSAPI_Stop(void)
 {
     g_running = 0;
 }
 int LSAPI_IsRunning(void)
 {
     return g_running;
 }
+void LSAPI_Register_Pgrp_Timer_Callback(LSAPI_On_Timer_pf cb)
+{
+    s_proc_group_timer_cb = cb;
+}
 int LSAPI_InitRequest( LSAPI_Request * pReq, int fd )
 {
+    int newfd;
     if ( !pReq )
         return -1;
     memset( pReq, 0, sizeof( LSAPI_Request ) );
@@ -1191,7 +1495,14 @@ int LSAPI_InitRequest( LSAPI_Request * pReq, int fd )
     pReq->m_respPktHeaderEnd = &pReq->m_respPktHeader[5];
     if ( allocateRespHeaderBuf( pReq, LSAPI_INIT_RESP_HEADER_LEN ) == -1 )
         return -1;
+    if ( fd == STDIN_FILENO )
+    {
+        fd = dup( fd );
+        newfd = open( "/dev/null", O_RDWR );
+        dup2( newfd, STDIN_FILENO );
+    }
     if ( isPipe( fd ) )
     {
         pReq->m_fdListen = -1;
@@ -1206,24 +1517,25 @@ int LSAPI_InitRequest( LSAPI_Request * pReq, int fd )
     return 0;
 }
 int LSAPI_Is_Listen( void )
 {
     return LSAPI_Is_Listen_r( &g_req );
 }
 int LSAPI_Is_Listen_r( LSAPI_Request * pReq)
 {
     return pReq->m_fdListen != -1;
 }
 int LSAPI_Accept_r( LSAPI_Request * pReq )
 {
     char        achPeer[128];
     socklen_t   len;
     int         nodelay = 1;
     if ( !pReq )
         return -1;
     if ( LSAPI_Finish_r( pReq ) == -1 )
@@ -1247,9 +1559,14 @@ int LSAPI_Accept_r( LSAPI_Request * pReq )
                 }
                 else
                 {
+                    if (s_worker_status)
+                        __sync_lock_test_and_set(&s_worker_status->m_state,
+                                                 LSAPI_STATE_CONNECTED);
+                    if (s_busy_workers)
+                        __sync_fetch_and_add(s_busy_workers, 1);
                     lsapi_set_nblock( pReq->m_fd , 0 );
                     if (((struct sockaddr *)&achPeer)->sa_family == AF_INET )
-                    {
+                    {
                         setsockopt(pReq->m_fd, IPPROTO_TCP, TCP_NODELAY,
                                    (char *)&nodelay, sizeof(nodelay));
                     }
@@ -1266,15 +1583,19 @@ int LSAPI_Accept_r( LSAPI_Request * pReq )
         if ( !readReq( pReq ) )
             break;
         //abort();
-        lsapi_close( pReq->m_fd );
-        pReq->m_fd = -1;
+        lsapi_close_connection(pReq);
         LSAPI_Reset_r( pReq );
     }
     return 0;
 }
-static struct lsapi_packet_header   finish = {'L', 'S',
-                LSAPI_RESP_END, LSAPI_ENDIAN, {LSAPI_PACKET_HEADER_LEN} };
+static struct lsapi_packet_header   finish_close[2] =
+{
+    {'L', 'S', LSAPI_RESP_END, LSAPI_ENDIAN, {LSAPI_PACKET_HEADER_LEN} },
+    {'L', 'S', LSAPI_CONN_CLOSE, LSAPI_ENDIAN, {LSAPI_PACKET_HEADER_LEN} }
+};
 int LSAPI_Finish_r( LSAPI_Request * pReq )
 {
@@ -1293,8 +1614,8 @@ int LSAPI_Finish_r( LSAPI_Request * pReq )
             {
                 Flush_RespBuf_r( pReq );
             }
-            pReq->m_pIovecCur->iov_base = (void *)&finish;
+            pReq->m_pIovecCur->iov_base = (void *)finish_close;
             pReq->m_pIovecCur->iov_len  = LSAPI_PACKET_HEADER_LEN;
             pReq->m_totalLen += LSAPI_PACKET_HEADER_LEN;
             ++pReq->m_pIovecCur;
@@ -1306,27 +1627,62 @@ int LSAPI_Finish_r( LSAPI_Request * pReq )
 }
-void LSAPI_Reset_r( LSAPI_Request * pReq )
-{
-    pReq->m_pRespBufPos         = pReq->m_pRespBuf;
-    pReq->m_pIovecCur           = pReq->m_pIovecToWrite = pReq->m_pIovec + 1;
-    pReq->m_pRespHeaderBufPos   = pReq->m_pRespHeaderBuf;
-    memset( &pReq->m_pHeaderIndex, 0,
-            (char *)(pReq->m_respHeaderLen) - (char *)&pReq->m_pHeaderIndex );
-}
-int LSAPI_Release_r( LSAPI_Request * pReq )
+int LSAPI_End_Response_r(LSAPI_Request * pReq)
 {
-    if ( pReq->m_pReqBuf )
+    if (!pReq)
+        return -1;
+    if (pReq->m_reqState & LSAPI_ST_BACKGROUND)
+        return 0;
+    if (pReq->m_reqState)
+    {
+        if ( pReq->m_fd != -1 )
+        {
+            if ( pReq->m_reqState & LSAPI_ST_RESP_HEADER )
+            {
+                if ( pReq->m_pRespHeaderBufPos <= pReq->m_pRespHeaderBuf )
+                    return 0;
+                LSAPI_FinalizeRespHeaders_r( pReq );
+            }
+            if ( pReq->m_pRespBufPos != pReq->m_pRespBuf )
+            {
+                Flush_RespBuf_r( pReq );
+            }
+            pReq->m_pIovecCur->iov_base = (void *)finish_close;
+            pReq->m_pIovecCur->iov_len  = LSAPI_PACKET_HEADER_LEN << 1;
+            pReq->m_totalLen += LSAPI_PACKET_HEADER_LEN << 1;
+            ++pReq->m_pIovecCur;
+            LSAPI_Flush_r( pReq );
+            lsapi_close_connection(pReq);
+        }
+        pReq->m_reqState |= LSAPI_ST_BACKGROUND;
+    }
+    return 0;
+}
+void LSAPI_Reset_r( LSAPI_Request * pReq )
+{
+    pReq->m_pRespBufPos         = pReq->m_pRespBuf;
+    pReq->m_pIovecCur           = pReq->m_pIovecToWrite = pReq->m_pIovec + 1;
+    pReq->m_pRespHeaderBufPos   = pReq->m_pRespHeaderBuf;
+    memset( &pReq->m_pHeaderIndex, 0,
+            (char *)(pReq->m_respHeaderLen) - (char *)&pReq->m_pHeaderIndex );
+}
+int LSAPI_Release_r( LSAPI_Request * pReq )
+{
+    if ( pReq->m_pReqBuf )
         free( pReq->m_pReqBuf );
     if ( pReq->m_pSpecialEnvList )
         free( pReq->m_pSpecialEnvList );
     if ( pReq->m_pEnvList )
         free( pReq->m_pEnvList );
     if ( pReq->m_pRespHeaderBuf )
-        free( pReq->m_pRespHeaderBuf );
+        free( pReq->m_pRespHeaderBuf );
     return 0;
 }
@@ -1339,13 +1695,16 @@ char * LSAPI_GetHeader_r( LSAPI_Request * pReq, int headerIndex )
     off = pReq->m_pHeaderIndex->m_headerOff[ headerIndex ];
     if ( !off )
         return NULL;
-        if ( *(pReq->m_pHttpHeader + off +
-                 pReq->m_pHeaderIndex->m_headerLen[ headerIndex ]) )
-                *( pReq->m_pHttpHeader + off +
-                        pReq->m_pHeaderIndex->m_headerLen[ headerIndex ]) = 0;
+    if ( *(pReq->m_pHttpHeader + off
+        + pReq->m_pHeaderIndex->m_headerLen[ headerIndex ]) )
+    {
+        *( pReq->m_pHttpHeader + off
+            + pReq->m_pHeaderIndex->m_headerLen[ headerIndex ]) = 0;
+    }
     return pReq->m_pHttpHeader + off;
 }
 static int readBodyToReqBuf( LSAPI_Request * pReq )
 {
     off_t bodyLeft;
@@ -1360,7 +1719,7 @@ static int readBodyToReqBuf( LSAPI_Request * pReq )
         return -1;
     if ( len > bodyLeft )
         len = bodyLeft;
     len = lsapi_read( pReq->m_fd, pReq->m_pReqBuf + pReq->m_bufRead, len );
     if ( len > 0 )
         pReq->m_bufRead += len;
@@ -1382,7 +1741,6 @@ int LSAPI_ReqBodyGetChar_r( LSAPI_Request * pReq )
 }
 int LSAPI_ReqBodyGetLine_r( LSAPI_Request * pReq, char * pBuf, size_t bufLen, int *getLF )
 {
     ssize_t len;
@@ -1391,12 +1749,12 @@ int LSAPI_ReqBodyGetLine_r( LSAPI_Request * pReq, char * pBuf, size_t bufLen, in
     char * pBufCur = pBuf;
     char * pCur;
     char * p;
-    if (!pReq || (pReq->m_fd ==-1) ||( !pBuf )||(bufLen < 0 )|| !getLF )
+    if (!pReq || pReq->m_fd == -1 || !pBuf || !getLF)
         return -1;
     *getLF = 0;
     while( (left = pBufEnd - pBufCur ) > 0 )
     {
         len = pReq->m_bufRead - pReq->m_bufProcessed;
         if ( len <= 0 )
         {
@@ -1417,7 +1775,7 @@ int LSAPI_ReqBodyGetLine_r( LSAPI_Request * pReq, char * pBuf, size_t bufLen, in
         pReq->m_bufProcessed += len;
         pReq->m_reqBodyRead += len;
         if ( p )
         {
             *getLF = 1;
@@ -1425,7 +1783,7 @@ int LSAPI_ReqBodyGetLine_r( LSAPI_Request * pReq, char * pBuf, size_t bufLen, in
         }
     }
     *pBufCur = 0;
     return pBufCur - pBuf;
 }
@@ -1435,21 +1793,21 @@ ssize_t LSAPI_ReadReqBody_r( LSAPI_Request * pReq, char * pBuf, size_t bufLen )
     ssize_t len;
     off_t total;
     /* char *pOldBuf = pBuf; */
-    if (!pReq || (pReq->m_fd ==-1) || ( !pBuf )||(bufLen < 0 ))
+    if (!pReq || pReq->m_fd == -1 || !pBuf || (ssize_t)bufLen < 0)
         return -1;
     total = pReq->m_reqBodyLen - pReq->m_reqBodyRead;
     if ( total <= 0 )
         return 0;
-    if ( total < bufLen )
+    if ( total < (ssize_t)bufLen )
         bufLen = total;
     total = 0;
     len = pReq->m_bufRead - pReq->m_bufProcessed;
     if ( len > 0 )
     {
-        if ( len > bufLen )
+        if ( len > (ssize_t)bufLen )
             len = bufLen;
         memmove( pBuf, pReq->m_pReqBuf + pReq->m_bufProcessed, len );
         pReq->m_bufProcessed += len;
@@ -1475,7 +1833,7 @@ ssize_t LSAPI_ReadReqBody_r( LSAPI_Request * pReq, char * pBuf, size_t bufLen )
     }
     pReq->m_reqBodyRead += total;
     return total;
 }
@@ -1488,8 +1846,12 @@ ssize_t LSAPI_Write_r( LSAPI_Request * pReq, const char * pBuf, size_t len )
     ssize_t toWrite;
     ssize_t packetLen;
     int skip = 0;
-    if ( !pReq || !pBuf || (pReq->m_fd == -1) )
+    if (!pReq || !pBuf)
+        return -1;
+    if (pReq->m_reqState & LSAPI_ST_BACKGROUND)
+        return len;
+    if (pReq->m_fd == -1)
         return -1;
     if ( pReq->m_reqState & LSAPI_ST_RESP_HEADER )
     {
@@ -1507,19 +1869,19 @@ ssize_t LSAPI_Write_r( LSAPI_Request * pReq, const char * pBuf, size_t len )
     }
     pReq->m_reqState |= LSAPI_ST_RESP_BODY;
-    if ( (len - skip) < pReq->m_pRespBufEnd - pReq->m_pRespBufPos )
+    if ( ((ssize_t)len - skip) < pReq->m_pRespBufEnd - pReq->m_pRespBufPos )
     {
         memmove( pReq->m_pRespBufPos, pBuf + skip, len - skip );
         pReq->m_pRespBufPos += len - skip;
         return len;
     }
     pHeader = pReq->m_respPktHeader;
     p       = pBuf + skip;
     pEnd    = pBuf + len;
     bufLen  = pReq->m_pRespBufPos - pReq->m_pRespBuf;
     while( ( toWrite = pEnd - p ) > 0 )
     {
         packetLen = toWrite + bufLen;
@@ -1528,7 +1890,7 @@ ssize_t LSAPI_Write_r( LSAPI_Request * pReq, const char * pBuf, size_t len )
             packetLen = LSAPI_MAX_DATA_PACKET_LEN;
             toWrite = packetLen - bufLen;
         }
         lsapi_buildPacketHeader( pHeader, LSAPI_RESP_STREAM,
                             packetLen + LSAPI_PACKET_HEADER_LEN );
         pReq->m_totalLen += packetLen + LSAPI_PACKET_HEADER_LEN;
@@ -1542,7 +1904,7 @@ ssize_t LSAPI_Write_r( LSAPI_Request * pReq, const char * pBuf, size_t len )
             pReq->m_pIovecCur->iov_base = (void *)pReq->m_pRespBuf;
             pReq->m_pIovecCur->iov_len  = bufLen;
             pReq->m_pRespBufPos = pReq->m_pRespBuf;
-            ++pReq->m_pIovecCur;
+            ++pReq->m_pIovecCur;
             bufLen = 0;
         }
@@ -1564,7 +1926,8 @@ ssize_t LSAPI_Write_r( LSAPI_Request * pReq, const char * pBuf, size_t len )
     return p - pBuf;
 }
-#if defined(__FreeBSD__ ) || defined(__NetBSD__) || defined(__OpenBSD__)
+#if defined(__FreeBSD__ ) || defined(__NetBSD__) || defined(__OpenBSD__)
 ssize_t gsendfile( int fdOut, int fdIn, off_t* off, size_t size )
 {
     ssize_t ret;
@@ -1579,6 +1942,7 @@ ssize_t gsendfile( int fdOut, int fdIn, off_t* off, size_t size )
 }
 #endif
 #if defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)
 ssize_t gsendfile( int fdOut, int fdIn, off_t* off, size_t size )
 {
@@ -1593,7 +1957,8 @@ ssize_t gsendfile( int fdOut, int fdIn, off_t* off, size_t size )
     return ret;
 }
 #endif
 #if defined(sun) || defined(__sun)
 #include <sys/sendfile.h>
 ssize_t gsendfile( int fdOut, int fdIn, off_t *off, size_t size )
@@ -1608,7 +1973,7 @@ ssize_t gsendfile( int fdOut, int fdIn, off_t *off, size_t size )
     ++n;
     size_t written;
-    ssize_t ret = ::sendfilev( fdOut, vec, n, &written );
+    ssize_t ret = sendfilev( fdOut, vec, n, &written );
     if (( !ret )||( errno == EAGAIN ))
         ret = written;
     if ( ret > 0 )
@@ -1617,11 +1982,14 @@ ssize_t gsendfile( int fdOut, int fdIn, off_t *off, size_t size )
 }
 #endif
 #if defined(linux) || defined(__linux) || defined(__linux__) || \
     defined(__gnu_linux__)
 #include <sys/sendfile.h>
 #define gsendfile sendfile
 #endif
 #if defined(HPUX)
 ssize_t gsendfile( int fdOut, int fdIn, off_t * off, size_t size )
 {
@@ -1629,6 +1997,7 @@ ssize_t gsendfile( int fdOut, int fdIn, off_t * off, size_t size )
 }
 #endif
 ssize_t LSAPI_sendfile_r( LSAPI_Request * pReq, int fdIn, off_t* off, size_t size )
 {
     struct lsapi_packet_header * pHeader = pReq->m_respPktHeader;
@@ -1639,16 +2008,16 @@ ssize_t LSAPI_sendfile_r( LSAPI_Request * pReq, int fdIn, off_t* off, size_t siz
         LSAPI_FinalizeRespHeaders_r( pReq );
     }
     pReq->m_reqState |= LSAPI_ST_RESP_BODY;
     LSAPI_Flush_r(pReq);
     lsapi_buildPacketHeader( pHeader, LSAPI_RESP_STREAM,
                             size + LSAPI_PACKET_HEADER_LEN );
     if (write(pReq->m_fd,  (const char *) pHeader, LSAPI_PACKET_HEADER_LEN ) != LSAPI_PACKET_HEADER_LEN)
         return -1;
     return gsendfile( pReq->m_fd, fdIn, off, size );
 }
@@ -1671,14 +2040,12 @@ void Flush_RespBuf_r( LSAPI_Request * pReq )
         pReq->m_pIovecCur->iov_base = (void *)pReq->m_pRespBuf;
         pReq->m_pIovecCur->iov_len  = bufLen;
         pReq->m_pRespBufPos = pReq->m_pRespBuf;
-        ++pReq->m_pIovecCur;
+        ++pReq->m_pIovecCur;
         bufLen = 0;
     }
 }
 int LSAPI_Flush_r( LSAPI_Request * pReq )
 {
     int ret = 0;
@@ -1703,17 +2070,16 @@ int LSAPI_Flush_r( LSAPI_Request * pReq )
     {
         Flush_RespBuf_r( pReq );
     }
     n = pReq->m_pIovecCur - pReq->m_pIovecToWrite;
     if ( n > 0 )
     {
         ret = lsapi_writev( pReq->m_fd, &pReq->m_pIovecToWrite,
                   n, pReq->m_totalLen );
         if ( ret < pReq->m_totalLen )
         {
-            lsapi_close( pReq->m_fd );
-            pReq->m_fd = -1;
+            lsapi_close_connection(pReq);
             ret = -1;
         }
         pReq->m_totalLen = 0;
@@ -1733,16 +2099,16 @@ ssize_t LSAPI_Write_Stderr_r( LSAPI_Request * pReq, const char * pBuf, size_t le
     int ret;
     struct iovec iov[2];
     struct iovec *pIov;
     if ( !pReq )
         return -1;
-    if (( pReq->m_fd == -1 )||(pReq->m_fd == pReq->m_fdListen ))
+    if (s_stderr_log_path || pReq->m_fd == -1 || pReq->m_fd == pReq->m_fdListen)
         return write( 2, pBuf, len );
     if ( pReq->m_pRespBufPos != pReq->m_pRespBuf )
     {
         LSAPI_Flush_r( pReq );
     }
     p       = pBuf;
     pEnd    = pBuf + len;
@@ -1768,23 +2134,32 @@ ssize_t LSAPI_Write_Stderr_r( LSAPI_Request * pReq, const char * pBuf, size_t le
                   2, totalLen );
         if ( ret < totalLen )
         {
-            lsapi_close( pReq->m_fd );
-            pReq->m_fd = -1;
+            lsapi_close_connection(pReq);
             ret = -1;
         }
     }
     return p - pBuf;
 }
 static char * GetHeaderVar( LSAPI_Request * pReq, const char * name )
 {
     int i;
+    char * pValue;
     for( i = 0; i < H_TRANSFER_ENCODING; ++i )
     {
         if ( pReq->m_pHeaderIndex->m_headerOff[i] )
         {
             if ( strcmp( name, CGI_HEADERS[i] ) == 0 )
-                return pReq->m_pHttpHeader + pReq->m_pHeaderIndex->m_headerOff[i];
+            {
+                pValue = pReq->m_pHttpHeader
+                         + pReq->m_pHeaderIndex->m_headerOff[i];
+                if ( *(pValue + pReq->m_pHeaderIndex->m_headerLen[i]) != '\0')
+                {
+                    *(pValue + pReq->m_pHeaderIndex->m_headerLen[i]) = '\0';
+                }
+                return pValue;
+            }
         }
     }
     if ( pReq->m_pHeader->m_cntUnknownHeaders > 0 )
@@ -1811,7 +2186,15 @@ static char * GetHeaderVar( LSAPI_Request * pReq, const char * name )
                 ++p; ++pKey;
             }
             if (( pKey == pKeyEnd )&& (!*p ))
-                return pReq->m_pHttpHeader + pCur->valueOff;
+            {
+                pValue = pReq->m_pHttpHeader + pCur->valueOff;
+                if ( *(pValue + pCur->valueLen) != '\0')
+                {
+                    *(pValue + pCur->valueLen) = '\0';
+                }
+                return pValue;
+            }
             ++pCur;
         }
     }
@@ -1838,6 +2221,7 @@ char * LSAPI_GetEnv_r( LSAPI_Request * pReq, const char * name )
     return NULL;
 }
 struct _headerInfo
 {
     const char * _name;
@@ -1846,12 +2230,14 @@ struct _headerInfo
     int          _valueLen;
 };
 int compareValueLocation(const void * v1, const void *v2 )
 {
     return ((const struct _headerInfo *)v1)->_value -
-           ((const struct _headerInfo *)v2)->_value;
+           ((const struct _headerInfo *)v2)->_value;
 }
 int LSAPI_ForeachOrgHeader_r( LSAPI_Request * pReq,
             LSAPI_CB_EnvHandler fn, void * arg )
 {
@@ -1861,9 +2247,13 @@ int LSAPI_ForeachOrgHeader_r( LSAPI_Request * pReq,
     int ret;
     int count = 0;
     struct _headerInfo headers[512];
     if ( !pReq || !fn )
         return -1;
+    if ( !pReq->m_pHeaderIndex )
+        return 0;
     for( i = 0; i < H_TRANSFER_ENCODING; ++i )
     {
         if ( pReq->m_pHeaderIndex->m_headerOff[i] )
@@ -1876,7 +2266,7 @@ int LSAPI_ForeachOrgHeader_r( LSAPI_Request * pReq,
             headers[count]._value = pValue;
             headers[count]._valueLen = len;
             ++count;
             //ret = (*fn)( HTTP_HEADERS[i], HTTP_HEADER_LEN[i],
             //            pValue, len, arg );
             //if ( ret <= 0 )
@@ -1894,6 +2284,7 @@ int LSAPI_ForeachOrgHeader_r( LSAPI_Request * pReq,
         {
             pKey = pReq->m_pHttpHeader + pCur->nameOff;
             keyLen = pCur->nameLen;
+            *(pKey + keyLen ) = 0;
             pValue = pReq->m_pHttpHeader + pCur->valueOff;
             *(pValue + pCur->valueLen ) = 0;
@@ -1904,7 +2295,7 @@ int LSAPI_ForeachOrgHeader_r( LSAPI_Request * pReq,
             ++count;
             if ( count == 512 )
                 break;
-            //ret = (*fn)( pKey, keyLen,
+            //ret = (*fn)( pKey, keyLen,
             //            pValue, pCur->valueLen, arg );
             //if ( ret <= 0 )
             //    return ret;
@@ -1914,13 +2305,12 @@ int LSAPI_ForeachOrgHeader_r( LSAPI_Request * pReq,
     qsort( headers, count, sizeof( struct _headerInfo ), compareValueLocation );
     for( i = 0; i < count; ++i )
     {
-        ret = (*fn)( headers[i]._name, headers[i]._nameLen,
+        ret = (*fn)( headers[i]._name, headers[i]._nameLen,
                     headers[i]._value, headers[i]._valueLen, arg );
         if ( ret <= 0 )
             return ret;
     }
     return count;
 }
@@ -1981,7 +2371,7 @@ int LSAPI_ForeachHeader_r( LSAPI_Request * pReq,
             pValue = pReq->m_pHttpHeader + pCur->valueOff;
             *(pValue + pCur->valueLen ) = 0;
-            ret = (*fn)( achHeaderName, keyLen,
+            ret = (*fn)( achHeaderName, keyLen,
                         pValue, pCur->valueLen, arg );
             if ( ret <= 0 )
                 return ret;
@@ -1989,9 +2379,9 @@ int LSAPI_ForeachHeader_r( LSAPI_Request * pReq,
         }
     }
     return count + pReq->m_pHeader->m_cntUnknownHeaders;
 }
 static int EnvForeach( struct LSAPI_key_value_pair * pEnv,
             int n, LSAPI_CB_EnvHandler fn, void * arg )
 {
@@ -2011,7 +2401,6 @@ static int EnvForeach( struct LSAPI_key_value_pair * pEnv,
 }
 int LSAPI_ForeachEnv_r( LSAPI_Request * pReq,
             LSAPI_CB_EnvHandler fn, void * arg )
 {
@@ -2026,7 +2415,6 @@ int LSAPI_ForeachEnv_r( LSAPI_Request * pReq,
 }
 int LSAPI_ForeachSpecialEnv_r( LSAPI_Request * pReq,
             LSAPI_CB_EnvHandler fn, void * arg )
 {
@@ -2043,7 +2431,6 @@ int LSAPI_ForeachSpecialEnv_r( LSAPI_Request * pReq,
 }
 int LSAPI_FinalizeRespHeaders_r( LSAPI_Request * pReq )
 {
     if ( !pReq || !pReq->m_pIovec )
@@ -2058,7 +2445,7 @@ int LSAPI_FinalizeRespHeaders_r( LSAPI_Request * pReq )
         pReq->m_totalLen += pReq->m_pIovecCur->iov_len;
         ++pReq->m_pIovecCur;
     }
     pReq->m_pIovec->iov_len  = sizeof( struct lsapi_resp_header)
             + pReq->m_respHeader.m_respInfo.m_cntHeaders * sizeof( short );
     pReq->m_totalLen += pReq->m_pIovec->iov_len;
@@ -2071,11 +2458,11 @@ int LSAPI_FinalizeRespHeaders_r( LSAPI_Request * pReq )
 }
-int LSAPI_AppendRespHeader2_r( LSAPI_Request * pReq, const char * pHeaderName,
+int LSAPI_AppendRespHeader2_r( LSAPI_Request * pReq, const char * pHeaderName,
                               const char * pHeaderValue )
 {
     int nameLen, valLen, len;
-    if ( !pReq || !pHeaderName || !pHeaderValue )
+    if ( !pReq || !pHeaderName || !pHeaderValue )
         return -1;
     if ( pReq->m_reqState & LSAPI_ST_RESP_BODY )
         return -1;
@@ -2127,7 +2514,6 @@ int LSAPI_AppendRespHeader2_r( LSAPI_Request * pReq, const char * pHeaderName,
 }
 int LSAPI_AppendRespHeader_r( LSAPI_Request * pReq, const char * pBuf, int len )
 {
     if ( !pReq || !pBuf || len <= 0 || len > LSAPI_RESP_HTTP_HEADER_MAX )
@@ -2208,9 +2594,9 @@ int LSAPI_CreateListenSock2( const struct sockaddr * pServerAddr, int backlog )
     close(fd);
     errno = ret;
     return -1;
 }
 int LSAPI_ParseSockAddr( const char * pBind, struct sockaddr * pAddr )
 {
     char achAddr[256];
@@ -2219,14 +2605,15 @@ int LSAPI_ParseSockAddr( const char * pBind, struct sockaddr * pAddr )
     struct addrinfo *res, hints;
     int  doAddrInfo = 0;
     int port;
     if ( !pBind )
         return -1;
     while( isspace( *pBind ) )
         ++pBind;
-    strncpy( achAddr, pBind, 256 );
+    strncpy(achAddr, pBind, 255);
+    achAddr[255] = 0;
     switch( *p )
     {
@@ -2243,7 +2630,7 @@ int LSAPI_ParseSockAddr( const char * pBind, struct sockaddr * pAddr )
         if ( !pEnd )
             return -1;
         *pEnd++ = 0;
         if ( *p == '*' )
         {
             strcpy( achAddr, "::" );
@@ -2258,7 +2645,7 @@ int LSAPI_ParseSockAddr( const char * pBind, struct sockaddr * pAddr )
         if ( !pEnd )
             return -1;
         *pEnd++ = 0;
         doAddrInfo = 0;
         if ( *p == '*' )
         {
@@ -2278,7 +2665,7 @@ int LSAPI_ParseSockAddr( const char * pBind, struct sockaddr * pAddr )
     }
     if ( *pEnd == ':' )
         ++pEnd;
     port = atoi( pEnd );
     if (( port <= 0 )||( port > 65535 ))
         return -1;
@@ -2299,15 +2686,16 @@ int LSAPI_ParseSockAddr( const char * pBind, struct sockaddr * pAddr )
         memcpy(pAddr, res->ai_addr, res->ai_addrlen);
         freeaddrinfo(res);
     }
     if ( pAddr->sa_family == AF_INET )
         ((struct sockaddr_in *)pAddr)->sin_port = htons( port );
     else
         ((struct sockaddr_in6 *)pAddr)->sin6_port = htons( port );
     return 0;
 }
 int LSAPI_CreateListenSock( const char * pBind, int backlog )
 {
     char serverAddr[128];
@@ -2321,25 +2709,8 @@ int LSAPI_CreateListenSock( const char * pBind, int backlog )
     return fd;
 }
-static fn_select_t g_fnSelect = select;
-typedef struct _lsapi_child_status
-{
-    int     m_pid;
-    long    m_tmStart;
-    volatile short   m_iKillSent;
-    volatile short   m_inProcess;
-    volatile int     m_iReqCounter;
-    volatile long    m_tmWaitBegin;
-    volatile long    m_tmReqBegin;
-    volatile long    m_tmLastCheckPoint;
-}
-lsapi_child_status;
-static lsapi_child_status * s_pChildStatus = NULL;
+static fn_select_t g_fnSelect = select;
 typedef struct _lsapi_prefork_server
 {
     int m_fd;
@@ -2351,16 +2722,17 @@ typedef struct _lsapi_prefork_server
     int m_iChildrenMaxIdleTime;
     int m_iMaxReqProcessTime;
     int m_iAvoidFork;
     lsapi_child_status * m_pChildrenStatus;
-}lsapi_prefork_server;
+    lsapi_child_status * m_pChildrenStatusCur;
+    lsapi_child_status * m_pChildrenStatusEnd;
+}lsapi_prefork_server;
 static lsapi_prefork_server * g_prefork_server = NULL;
 int LSAPI_Init_Prefork_Server( int max_children, fn_select_t fp, int avoidFork )
 {
-    int pid;
     if ( g_prefork_server )
         return 0;
     if ( max_children <= 1 )
@@ -2368,7 +2740,9 @@ int LSAPI_Init_Prefork_Server( int max_children, fn_select_t fp, int avoidFork )
     if ( max_children >= 10000)
         max_children = 10000;
+    if (s_max_busy_workers == 0)
+        s_max_busy_workers = max_children / 2 + 1;
     g_prefork_server = (lsapi_prefork_server *)malloc( sizeof( lsapi_prefork_server ) );
     if ( !g_prefork_server )
         return -1;
@@ -2378,20 +2752,27 @@ int LSAPI_Init_Prefork_Server( int max_children, fn_select_t fp, int avoidFork )
         g_fnSelect = fp;
     s_ppid = getppid();
-    pid = getpid();
-    setpgid( pid, pid );
+    s_pid = getpid();
+    setpgid( s_pid, s_pid );
+#if defined(linux) || defined(__linux) || defined(__linux__) || defined(__gnu_linux__)
+    s_total_pages = sysconf(_SC_PHYS_PAGES);
+#endif
     g_prefork_server->m_iAvoidFork = avoidFork;
     g_prefork_server->m_iMaxChildren = max_children;
     g_prefork_server->m_iExtraChildren = ( avoidFork ) ? 0 : (max_children / 3) ;
     g_prefork_server->m_iMaxIdleChildren = ( avoidFork ) ? (max_children + 1) : (max_children / 3);
     if ( g_prefork_server->m_iMaxIdleChildren == 0 )
         g_prefork_server->m_iMaxIdleChildren = 1;
     g_prefork_server->m_iChildrenMaxIdleTime = 300;
-    g_prefork_server->m_iMaxReqProcessTime = 300;
-    return 0;
+    g_prefork_server->m_iMaxReqProcessTime = 3600;
+    setsid();
+    return 0;
 }
 void LSAPI_Set_Server_fd( int fd )
 {
     if( g_prefork_server )
@@ -2425,12 +2806,8 @@ static int lsapi_accept( int fdListen )
 }
-static int s_req_processed = 0;
-static int s_max_reqs = 10000;
+static unsigned int s_max_reqs = UINT_MAX;
 static int s_max_idle_secs = 300;
 static int s_stop;
 static void lsapi_cleanup(int signal)
@@ -2438,25 +2815,57 @@ static void lsapi_cleanup(int signal)
     s_stop = signal;
 }
 static lsapi_child_status * find_child_status( int pid )
 {
     lsapi_child_status * pStatus = g_prefork_server->m_pChildrenStatus;
-    lsapi_child_status * pEnd = g_prefork_server->m_pChildrenStatus + g_prefork_server->m_iMaxChildren * 2;
+    lsapi_child_status * pEnd = g_prefork_server->m_pChildrenStatusEnd;
     while( pStatus < pEnd )
     {
         if ( pStatus->m_pid == pid )
+        {
+            if (pid == 0)
+            {
+                memset(pStatus, 0, sizeof( *pStatus ) );
+                pStatus->m_pid = -1;
+            }
+            if ( pStatus + 1 > g_prefork_server->m_pChildrenStatusCur )
+                g_prefork_server->m_pChildrenStatusCur = pStatus + 1;
             return pStatus;
+        }
         ++pStatus;
     }
     return NULL;
 }
+void LSAPI_reset_server_state( void )
+{
+    /*
+       Reset child status
+    */
+    g_prefork_server->m_iCurChildren = 0;
+    lsapi_child_status * pStatus = g_prefork_server->m_pChildrenStatus;
+    lsapi_child_status * pEnd = g_prefork_server->m_pChildrenStatusEnd;
+    while( pStatus < pEnd )
+    {
+        pStatus->m_pid = 0;
+        ++pStatus;
+    }
+    if (s_busy_workers)
+        __sync_lock_release(s_busy_workers);
+    if (s_accepting_workers)
+        __sync_lock_release(s_accepting_workers);
+}
 static void lsapi_sigchild( int signal )
 {
     int status, pid;
     lsapi_child_status * child_status;
+    if (g_prefork_server == NULL)
+        return;
     while( 1 )
     {
         pid = waitpid( -1, &status, WNOHANG|WUNTRACED );
@@ -2468,25 +2877,60 @@ static void lsapi_sigchild( int signal )
         {
             int sig_num = WTERMSIG( status );
             int dump = WCOREDUMP( status );
-            fprintf( stderr, "Child process with pid: %d was killed by signal: %d, core dump: %d\n", pid, sig_num, dump );
+            lsapi_log("Child process with pid: %d was killed by signal: "
+                     "%d, core dump: %d\n", pid, sig_num, dump );
+        }
+        if ( pid == s_pid_dump_debug_info )
+        {
+            pid = 0;
+            continue;
+        }
+        if ( pid == s_ignore_pid )
+        {
+            pid = 0;
+            s_ignore_pid = -1;
+            continue;
         }
         child_status = find_child_status( pid );
         if ( child_status )
         {
+            if (__sync_bool_compare_and_swap(&child_status->m_state,
+                                             LSAPI_STATE_CONNECTED,
+                                             LSAPI_STATE_IDLE))
+            {
+                if (s_busy_workers)
+                    __sync_fetch_and_sub(s_busy_workers, 1);
+            }
+            else if (__sync_bool_compare_and_swap(&child_status->m_state,
+                                                  LSAPI_STATE_ACCEPTING,
+                                                  LSAPI_STATE_IDLE))
+            {
+                if (s_accepting_workers)
+                    __sync_fetch_and_sub(s_accepting_workers, 1);
+            }
             child_status->m_pid = 0;
             --g_prefork_server->m_iCurChildren;
         }
     }
+    while(( g_prefork_server->m_pChildrenStatusCur > g_prefork_server->m_pChildrenStatus )
+            &&( g_prefork_server->m_pChildrenStatusCur[-1].m_pid == 0 ))
+        --g_prefork_server->m_pChildrenStatusCur;
 }
-static int lsapi_init_children_status()
+static int lsapi_init_children_status(void)
 {
+    char * pBuf;
     int size = 4096;
+    int max_children;
+    if (g_prefork_server->m_pChildrenStatus)
+        return 0;
+    max_children = g_prefork_server->m_iMaxChildren
+                        + g_prefork_server->m_iExtraChildren;
-    char * pBuf;
-    size = g_prefork_server->m_iMaxChildren * sizeof( lsapi_child_status ) * 2;
-    size = (size + 4095 ) / 4096 * 4096;
+    size = max_children * sizeof( lsapi_child_status ) * 2 + 3 * sizeof(int);
+    size = (size + 4095) / 4096 * 4096;
     pBuf =( char*) mmap( NULL, size, PROT_READ | PROT_WRITE,
         MAP_ANON | MAP_SHARED, -1, 0 );
     if ( pBuf == MAP_FAILED )
@@ -2495,25 +2939,47 @@ static int lsapi_init_children_status()
         return -1;
     }
     memset( pBuf, 0, size );
-    g_prefork_server->m_pChildrenStatus = (lsapi_child_status *)pBuf;
+    g_prefork_server->m_pChildrenStatus = (lsapi_child_status *)pBuf;
+    g_prefork_server->m_pChildrenStatusCur = (lsapi_child_status *)pBuf;
+    g_prefork_server->m_pChildrenStatusEnd = (lsapi_child_status *)pBuf + max_children;
+    s_busy_workers = (int *)g_prefork_server->m_pChildrenStatusEnd;
+    s_accepting_workers = s_busy_workers + 1;
+    s_global_counter = s_accepting_workers + 1;
+    s_avail_pages = (size_t *)(s_global_counter + 1);
+    setsid();
     return 0;
 }
 static void dump_debug_info( lsapi_child_status * pStatus, long tmCur )
 {
     char achCmd[1024];
-    int pid = fork();
-    if ( pid != 0 )
-        return;
-    fprintf( stderr, "[%s] Possible runaway process, PPID: %d, PID: %d, reqCount: %d, process time: %ld, checkpoint time: %ld, start time: %ld\n",
-                ctime(&tmCur), getpid(), pStatus->m_pid, pStatus->m_iReqCounter,
-                tmCur - pStatus->m_tmReqBegin, tmCur - pStatus->m_tmLastCheckPoint, tmCur - pStatus->m_tmStart );
-    snprintf( achCmd, 1024, "gdb --batch -ex \"attach %d\" -ex \"set height 0\" -ex \"bt\" >&2;PATH=$PATH:/usr/sbin lsof -p %d >&2", pStatus->m_pid, pStatus->m_pid );
-    if ( system( achCmd ) == -1 )
-        perror( "system()" );
-    exit( 0 );
+    if ( s_pid_dump_debug_info )
+    {
+        if ( kill( s_pid_dump_debug_info, 0 ) == 0 )
+            return;
+    }
+    lsapi_log("Possible runaway process, UID: %d, PPID: %d, PID: %d, "
+             "reqCount: %d, process time: %ld, checkpoint time: %ld, start "
+             "time: %ld\n", getuid(), getppid(), pStatus->m_pid,
+             pStatus->m_iReqCounter, tmCur - pStatus->m_tmReqBegin,
+             tmCur - pStatus->m_tmLastCheckPoint, tmCur - pStatus->m_tmStart );
+    s_pid_dump_debug_info = fork();
+    if (s_pid_dump_debug_info == 0)
+    {
+        snprintf( achCmd, 1024, "gdb --batch -ex \"attach %d\" -ex \"set height 0\" "
+                "-ex \"bt\" >&2;PATH=$PATH:/usr/sbin lsof -p %d >&2",
+                pStatus->m_pid, pStatus->m_pid );
+        if ( system( achCmd ) == -1 )
+            perror( "system()" );
+        exit( 0 );
+    }
 }
 static void lsapi_check_child_status( long tmCur )
 {
     int idle = 0;
@@ -2521,26 +2987,30 @@ static void lsapi_check_child_status( long tmCur )
     int dying = 0;
     int count = 0;
     lsapi_child_status * pStatus = g_prefork_server->m_pChildrenStatus;
-    lsapi_child_status * pEnd = g_prefork_server->m_pChildrenStatus + g_prefork_server->m_iMaxChildren * 2;
+    lsapi_child_status * pEnd = g_prefork_server->m_pChildrenStatusCur;
     while( pStatus < pEnd )
     {
         tobekilled = 0;
-        if ( pStatus->m_pid != 0 )
+        if ( pStatus->m_pid != 0 && pStatus->m_pid != -1)
         {
             ++count;
             if ( !pStatus->m_inProcess )
             {
-                if (( g_prefork_server->m_iCurChildren - dying > g_prefork_server->m_iMaxChildren)||
-                    ( idle > g_prefork_server->m_iMaxIdleChildren ))
+                if (g_prefork_server->m_iCurChildren - dying
+                        > g_prefork_server->m_iMaxChildren
+                    || idle > g_prefork_server->m_iMaxIdleChildren)
                 {
-                    tobekilled = SIGUSR1;
+                    ++pStatus->m_iKillSent;
+                    //tobekilled = SIGUSR1;
                 }
                 else
                 {
-                    if (( s_max_idle_secs> 0)&&(tmCur - pStatus->m_tmWaitBegin > s_max_idle_secs + 5 ))
+                    if (s_max_idle_secs> 0
+                        && tmCur - pStatus->m_tmWaitBegin > s_max_idle_secs + 5)
                     {
-                        tobekilled = SIGUSR1;
+                        ++pStatus->m_iKillSent;
+                        //tobekilled = SIGUSR1;
                     }
                 }
                 if ( !tobekilled )
@@ -2548,62 +3018,88 @@ static void lsapi_check_child_status( long tmCur )
             }
             else
             {
-                if ( tmCur - pStatus->m_tmReqBegin >
-                        g_prefork_server->m_iMaxReqProcessTime )
+                if (tmCur - pStatus->m_tmReqBegin >
+                        g_prefork_server->m_iMaxReqProcessTime)
                 {
-                    if (( ( pStatus->m_iKillSent % 5 ) == 0 )&&( s_dump_debug_info ))
+                    if ((pStatus->m_iKillSent % 5) == 0 && s_dump_debug_info)
                         dump_debug_info( pStatus, tmCur );
                     if ( pStatus->m_iKillSent > 5 )
                     {
                         tobekilled = SIGKILL;
-                        fprintf( stderr, "Force killing runaway process PID: %d with SIGKILL\n", pStatus->m_pid );
+                        lsapi_log("Force killing runaway process PID: %d"
+                                 " with SIGKILL\n", pStatus->m_pid );
                     }
                     else
                     {
                         tobekilled = SIGTERM;
-                        fprintf( stderr, "Killing runaway process PID: %d with SIGTERM\n", pStatus->m_pid );
+                        lsapi_log("Killing runaway process PID: %d with "
+                                 "SIGTERM\n", pStatus->m_pid );
                     }
                 }
             }
             if ( tobekilled )
             {
-                kill( pStatus->m_pid, tobekilled );
-                ++pStatus->m_iKillSent;
-                ++dying;
+                if (( kill( pStatus->m_pid, tobekilled ) == -1 ) &&
+                    ( errno == ESRCH ))
+                {
+                    pStatus->m_pid = 0;
+                    --count;
+                }
+                else
+                {
+                    ++pStatus->m_iKillSent;
+                    ++dying;
+                }
             }
         }
         ++pStatus;
     }
-    if ( g_prefork_server->m_iCurChildren != count )
+    if ( abs( g_prefork_server->m_iCurChildren - count ) > 1 )
     {
-        fprintf( stderr, "Children tracking is wrong: PID: %d, Cur Childen: %d, count: %d, idle: %d, dying: %d\n", getpid(),
-                g_prefork_server->m_iCurChildren, count, idle, dying );
+        lsapi_log("Children tracking is wrong: Cur Children: %d,"
+                  " count: %d, idle: %d, dying: %d\n",
+                  g_prefork_server->m_iCurChildren, count, idle, dying );
     }
 }
-static int lsapi_all_children_must_die()
-{
-    int maxWait;
-    int sec =0;
-    g_prefork_server->m_iMaxReqProcessTime = 10;
-    g_prefork_server->m_iMaxIdleChildren = -1;
-    maxWait = 15;
-    while( g_prefork_server->m_iCurChildren && (sec < maxWait) )
-    {
-        lsapi_check_child_status(time(NULL));
-        sleep( 1 );
-        sec++;
-    }
-    if ( g_prefork_server->m_iCurChildren != 0 )
-        kill( -getpgrp(), SIGKILL );
-    return 0;
-}
+//static int lsapi_all_children_must_die(void)
+//{
+//    int maxWait;
+//    int sec =0;
+//    g_prefork_server->m_iMaxReqProcessTime = 10;
+//    g_prefork_server->m_iMaxIdleChildren = -1;
+//    maxWait = 15;
+//
+//    while( g_prefork_server->m_iCurChildren && (sec < maxWait) )
+//    {
+//        lsapi_check_child_status(time(NULL));
+//        sleep( 1 );
+//        sec++;
+//    }
+//    if ( g_prefork_server->m_iCurChildren != 0 )
+//        kill( -getpgrp(), SIGKILL );
+//    return 0;
+//}
+void set_skip_write()
+{   s_skip_write = 1;   }
-static int lsapi_prefork_server_accept( lsapi_prefork_server * pServer, LSAPI_Request * pReq )
+int is_enough_free_mem()
+{
+#if defined(linux) || defined(__linux) || defined(__linux__) || defined(__gnu_linux__)
+    //minimum 1GB or 10% available free memory
+    return (*s_avail_pages > s_min_avail_pages
+            || (*s_avail_pages * 10) / s_total_pages > 0);
+#endif
+    return 1;
+}
+static int lsapi_prefork_server_accept( lsapi_prefork_server * pServer,
+                                        LSAPI_Request * pReq )
 {
     struct sigaction act, old_term, old_quit, old_int,
                     old_usr1, old_child;
@@ -2616,12 +3112,14 @@ static int lsapi_prefork_server_accept( lsapi_prefork_server * pServer, LSAPI_Re
     fd_set          readfds;
     struct timeval  timeout;
+    sigset_t mask;
+    sigset_t orig_mask;
     lsapi_init_children_status();
-    setsid();
     act.sa_flags = 0;
     act.sa_handler = lsapi_sigchild;
+    sigemptyset(&(act.sa_mask));
     if( sigaction( SIGCHLD, &act, &old_child ) )
     {
         perror( "Can't set signal handler for SIGCHILD" );
@@ -2631,6 +3129,7 @@ static int lsapi_prefork_server_accept( lsapi_prefork_server * pServer, LSAPI_Re
     /* Set up handler to kill children upon exit */
     act.sa_flags = 0;
     act.sa_handler = lsapi_cleanup;
+    sigemptyset(&(act.sa_mask));
     if( sigaction( SIGTERM, &act, &old_term ) ||
         sigaction( SIGINT,  &act, &old_int  ) ||
         sigaction( SIGUSR1, &act, &old_usr1 ) ||
@@ -2639,14 +3138,18 @@ static int lsapi_prefork_server_accept( lsapi_prefork_server * pServer, LSAPI_Re
         perror( "Can't set signals" );
         return -1;
     }
-    s_stop = 0;
     while( !s_stop )
     {
+        if (s_proc_group_timer_cb != NULL) {
+            s_proc_group_timer_cb(&s_ignore_pid);
+        }
         curTime = time( NULL );
         if (curTime != lastTime )
         {
             lastTime = curTime;
-            if (s_ppid && (getppid() != s_ppid ))
+            if (lsapi_parent_dead())
                 break;
             lsapi_check_child_status(curTime );
             if (pServer->m_iServerMaxIdle)
@@ -2662,27 +3165,31 @@ static int lsapi_prefork_server_accept( lsapi_prefork_server * pServer, LSAPI_Re
             }
         }
-        if ( pServer->m_iCurChildren >= (pServer->m_iMaxChildren + pServer->m_iExtraChildren ) )
-        {
-            usleep( 100000 );
-            continue;
-        }
+#if defined(linux) || defined(__linux) || defined(__linux__) || defined(__gnu_linux__)
+        *s_avail_pages = sysconf(_SC_AVPHYS_PAGES);
+//        lsapi_log("Memory total: %zd, free: %zd, free %%%zd\n",
+//                  s_total_pages, *s_avail_pages, *s_avail_pages * 100 / s_total_pages);
+#endif
         FD_ZERO( &readfds );
         FD_SET( pServer->m_fd, &readfds );
-        timeout.tv_sec = 1; timeout.tv_usec = 0;
-        if ((ret = (*g_fnSelect)(pServer->m_fd+1, &readfds, NULL, NULL, &timeout)) == 1 )
+        timeout.tv_sec = 1;
+        timeout.tv_usec = 0;
+        ret = (*g_fnSelect)(pServer->m_fd+1, &readfds, NULL, NULL, &timeout);
+        if (ret == 1 )
         {
-            /*
-            if ( pServer->m_iCurChildren >= 0 )
+            int accepting = 0;
+            if (s_accepting_workers)
+                accepting = __sync_add_and_fetch(s_accepting_workers, 0);
+            if (pServer->m_iCurChildren > 0
+                && accepting > 0)
             {
-                usleep( 10 );
-                FD_ZERO( &readfds );
-                FD_SET( pServer->m_fd, &readfds );
-                timeout.tv_sec = 0; timeout.tv_usec = 0;
-                if ( (*g_fnSelect)(pServer->m_fd+1, &readfds, NULL, NULL, &timeout) == 0 )
-                    continue;
-            }*/
+                usleep( 400);
+                while(accepting-- > 0)
+                    sched_yield();
+                continue;
+            }
         }
         else if ( ret == -1 )
         {
@@ -2696,21 +3203,60 @@ static int lsapi_prefork_server_accept( lsapi_prefork_server * pServer, LSAPI_Re
             continue;
         }
+        if (pServer->m_iCurChildren >=
+            pServer->m_iMaxChildren + pServer->m_iExtraChildren)
+        {
+            lsapi_log("Reached max children process limit: %d, extra: %d,"
+                     " current: %d, busy: %d, please increase LSAPI_CHILDREN.\n",
+                     pServer->m_iMaxChildren, pServer->m_iExtraChildren,
+                     pServer->m_iCurChildren,
+                     s_busy_workers ? *s_busy_workers : -1 );
+            usleep( 100000 );
+            continue;
+        }
         pReq->m_fd = lsapi_accept( pServer->m_fd );
         if ( pReq->m_fd != -1 )
         {
+            wait_secs = 0;
             child_status = find_child_status( 0 );
-            if ( child_status )
-                memset( child_status, 0, sizeof( *child_status ) );
+            sigemptyset( &mask );
+            sigaddset( &mask, SIGCHLD );
+            if ( sigprocmask(SIG_BLOCK, &mask, &orig_mask) < 0 )
+            {
+                perror( "sigprocmask(SIG_BLOCK) to block SIGCHLD" );
+            }
             pid = fork();
             if ( !pid )
             {
+                setsid();
+                if (sigprocmask(SIG_SETMASK, &orig_mask, NULL) < 0)
+                    perror( "sigprocmask( SIG_SETMASK ) to restore SIGMASK in child" );
                 g_prefork_server = NULL;
                 s_ppid = getppid();
+                s_pid = getpid();
                 s_req_processed = 0;
-                s_pChildStatus = child_status;
+                s_proc_group_timer_cb = NULL;
+                s_worker_status = child_status;
+                if (pthread_atfork_func)
+                    (*pthread_atfork_func)(NULL, NULL, set_skip_write);
+                __sync_lock_test_and_set(&s_worker_status->m_state,
+                                         LSAPI_STATE_CONNECTED);
+                if (s_busy_workers)
+                    __sync_add_and_fetch(s_busy_workers, 1);
                 lsapi_set_nblock( pReq->m_fd, 0 );
-                if ( pReq->m_fdListen != -1 )
+                //keep it open if busy_count is used.
+                if (s_busy_workers
+                    && *s_busy_workers > (pServer->m_iMaxChildren >> 1))
+                    s_keepListener = 1;
+                if ((s_uid == 0 || !s_keepListener || !is_enough_free_mem())
+                    && pReq->m_fdListen != -1 )
                 {
                     close( pReq->m_fdListen );
                     pReq->m_fdListen = -1;
@@ -2723,13 +3269,16 @@ static int lsapi_prefork_server_accept( lsapi_prefork_server * pServer, LSAPI_Re
                 sigaction( SIGUSR1, &old_usr1, 0 );
                 //init_conn_key( pReq->m_fd );
                 lsapi_notify_pid( pReq->m_fd );
-                if ( s_accept_notify )
-                    return notify_req_received( pReq->m_fd );
+                s_notified_pid = 1;
+                //if ( s_accept_notify )
+                //    return notify_req_received( pReq->m_fd );
                 return 0;
             }
             else if ( pid == -1 )
             {
-                perror( "fork() failed, please increase process limit" );
+                lsapi_perror("fork() failed, please increase process limit", errno);
+                if (child_status)
+                    child_status->m_pid = 0;
             }
             else
             {
@@ -2744,27 +3293,230 @@ static int lsapi_prefork_server_accept( lsapi_prefork_server * pServer, LSAPI_Re
             close( pReq->m_fd );
             pReq->m_fd = -1;
+            if (sigprocmask(SIG_SETMASK, &orig_mask, NULL) < 0)
+                perror( "sigprocmask( SIG_SETMASK ) to restore SIGMASK" );
         }
         else
         {
             if (( errno == EINTR )||( errno == EAGAIN))
                 continue;
-            perror( "accept() failed" );
+            lsapi_perror("accept() failed", errno);
             return -1;
         }
     }
     sigaction( SIGUSR1, &old_usr1, 0 );
-    kill( -getpgrp(), SIGUSR1 );
-    lsapi_all_children_must_die();  /* Sorry, children ;-) */
+    //kill( -getpgrp(), SIGUSR1 );
+    //lsapi_all_children_must_die();  /* Sorry, children ;-) */
     return -1;
 }
-void lsapi_error( const char * pMessage, int err_no )
+static struct sigaction old_term, old_quit, old_int,
+                    old_usr1, old_child;
+int LSAPI_Postfork_Child(LSAPI_Request * pReq)
+{
+    int max_children = g_prefork_server->m_iMaxChildren;
+    s_pid = getpid();
+    __sync_lock_test_and_set(&pReq->child_status->m_pid, s_pid);
+    s_worker_status = pReq->child_status;
+    setsid();
+    g_prefork_server = NULL;
+    s_ppid = getppid();
+    s_req_processed = 0;
+    s_proc_group_timer_cb = NULL;
+    if (pthread_atfork_func)
+        (*pthread_atfork_func)(NULL, NULL, set_skip_write);
+    __sync_lock_test_and_set(&s_worker_status->m_state,
+                                LSAPI_STATE_CONNECTED);
+    if (s_busy_workers)
+        __sync_add_and_fetch(s_busy_workers, 1);
+    lsapi_set_nblock( pReq->m_fd, 0 );
+    //keep it open if busy_count is used.
+    if (s_busy_workers
+        && *s_busy_workers > (max_children >> 1))
+        s_keepListener = 1;
+    if ((s_uid == 0 || !s_keepListener || !is_enough_free_mem())
+        && pReq->m_fdListen != -1 )
+    {
+        close(pReq->m_fdListen);
+        pReq->m_fdListen = -1;
+    }
+    //init_conn_key( pReq->m_fd );
+    lsapi_notify_pid(pReq->m_fd);
+    s_notified_pid = 1;
+    //if ( s_accept_notify )
+    //    return notify_req_received( pReq->m_fd );
+    return 0;
+}
+int LSAPI_Postfork_Parent(LSAPI_Request * pReq)
+{
+    ++g_prefork_server->m_iCurChildren;
+    if (pReq->child_status)
+    {
+        time_t curTime = time( NULL );
+        pReq->child_status->m_tmWaitBegin = curTime;
+        pReq->child_status->m_tmStart = curTime;
+    }
+    close(pReq->m_fd);
+    pReq->m_fd = -1;
+    return 0;
+}
+int LSAPI_Accept_Before_Fork(LSAPI_Request * pReq)
 {
-    fprintf( stderr, "%d: %s, errno: %d (%s)\n", getpid(), pMessage, err_no, strerror( err_no ) );
+    time_t          lastTime = 0;
+    time_t          curTime = 0;
+    fd_set          readfds;
+    struct timeval  timeout;
+    int             wait_secs = 0;
+    int             ret = 0;
+    lsapi_prefork_server * pServer = g_prefork_server;
+    struct sigaction act;
+    lsapi_init_children_status();
+    act.sa_flags = 0;
+    act.sa_handler = lsapi_sigchild;
+    sigemptyset(&(act.sa_mask));
+    if (sigaction(SIGCHLD, &act, &old_child))
+    {
+        perror( "Can't set signal handler for SIGCHILD" );
+        return -1;
+    }
+    /* Set up handler to kill children upon exit */
+    act.sa_flags = 0;
+    act.sa_handler = lsapi_cleanup;
+    sigemptyset(&(act.sa_mask));
+    if (sigaction(SIGTERM, &act, &old_term) ||
+        sigaction(SIGINT,  &act, &old_int ) ||
+        sigaction(SIGUSR1, &act, &old_usr1) ||
+        sigaction(SIGQUIT, &act, &old_quit))
+    {
+        perror( "Can't set signals" );
+        return -1;
+    }
+    s_stop = 0;
+    pReq->m_reqState = 0;
+    while(!s_stop)
+    {
+        if (s_proc_group_timer_cb != NULL) {
+            s_proc_group_timer_cb(&s_ignore_pid);
+        }
+        curTime = time(NULL);
+        if (curTime != lastTime)
+        {
+            lastTime = curTime;
+            if (lsapi_parent_dead())
+                break;
+            lsapi_check_child_status(curTime);
+            if (pServer->m_iServerMaxIdle)
+            {
+                if (pServer->m_iCurChildren <= 0)
+                {
+                    ++wait_secs;
+                    if ( wait_secs > pServer->m_iServerMaxIdle )
+                        return -1;
+                }
+                else
+                    wait_secs = 0;
+            }
+        }
+#if defined(linux) || defined(__linux) || defined(__linux__) || defined(__gnu_linux__)
+        *s_avail_pages = sysconf(_SC_AVPHYS_PAGES);
+//        lsapi_log("Memory total: %zd, free: %zd, free %%%zd\n",
+//                  s_total_pages, *s_avail_pages, *s_avail_pages * 100 / s_total_pages);
+#endif
+        FD_ZERO(&readfds);
+        FD_SET(pServer->m_fd, &readfds);
+        timeout.tv_sec = 1;
+        timeout.tv_usec = 0;
+        ret = (*g_fnSelect)(pServer->m_fd+1, &readfds, NULL, NULL, &timeout);
+        if (ret == 1 )
+        {
+            int accepting = 0;
+            if (s_accepting_workers)
+                accepting = __sync_add_and_fetch(s_accepting_workers, 0);
+            if (pServer->m_iCurChildren > 0
+                && accepting > 0)
+            {
+                usleep( 400);
+                while(accepting-- > 0)
+                    sched_yield();
+                continue;
+            }
+        }
+        else if (ret == -1)
+        {
+            if (errno == EINTR)
+                continue;
+            /* perror( "select()" ); */
+            break;
+        }
+        else
+        {
+            continue;
+        }
+        if (pServer->m_iCurChildren >=
+            pServer->m_iMaxChildren + pServer->m_iExtraChildren)
+        {
+            lsapi_log("Reached max children process limit: %d, extra: %d,"
+                     " current: %d, busy: %d, please increase LSAPI_CHILDREN.\n",
+                     pServer->m_iMaxChildren, pServer->m_iExtraChildren,
+                     pServer->m_iCurChildren,
+                     s_busy_workers ? *s_busy_workers : -1);
+            usleep(100000);
+            continue;
+        }
+        pReq->m_fd = lsapi_accept(pServer->m_fd);
+        if (pReq->m_fd != -1)
+        {
+            wait_secs = 0;
+            pReq->child_status = find_child_status(0);
+            ret = 0;
+            break;
+        }
+        else
+        {
+            if ((errno == EINTR) || (errno == EAGAIN))
+                continue;
+            lsapi_perror("accept() failed", errno);
+            ret = -1;
+            break;
+        }
+    }
+    sigaction(SIGCHLD, &old_child, 0);
+    sigaction(SIGTERM, &old_term, 0);
+    sigaction(SIGQUIT, &old_quit, 0);
+    sigaction(SIGINT,  &old_int,  0);
+    sigaction(SIGUSR1, &old_usr1, 0);
+    return ret;
 }
 int LSAPI_Prefork_Accept_r( LSAPI_Request * pReq )
 {
     int             fd;
@@ -2773,8 +3525,10 @@ int LSAPI_Prefork_Accept_r( LSAPI_Request * pReq )
     fd_set          readfds;
     struct timeval  timeout;
-    LSAPI_Finish_r( pReq );
+    if (s_skip_write)
+        return -1;
+    LSAPI_Finish_r( pReq );
     if ( g_prefork_server )
     {
@@ -2782,15 +3536,25 @@ int LSAPI_Prefork_Accept_r( LSAPI_Request * pReq )
             if ( lsapi_prefork_server_accept( g_prefork_server, pReq ) == -1 )
                 return -1;
     }
-    if ( s_req_processed >= s_max_reqs )
+    else if (s_req_processed > 0 && s_max_busy_workers > 0 && s_busy_workers)
+    {
+        ret = __sync_fetch_and_add(s_busy_workers, 0);
+        if (ret >= s_max_busy_workers)
+        {
+            send_conn_close_notification(pReq->m_fd);
+            lsapi_close_connection(pReq);
+        }
+    }
+    if ( (unsigned int)s_req_processed > s_max_reqs )
         return -1;
-    if ( s_pChildStatus )
+    if ( s_worker_status )
     {
-        s_pChildStatus->m_tmWaitBegin = time( NULL );
+        s_worker_status->m_tmWaitBegin = time( NULL );
     }
     while( g_running )
     {
         if ( pReq->m_fd != -1 )
@@ -2808,23 +3572,44 @@ int LSAPI_Prefork_Accept_r( LSAPI_Request * pReq )
         {
             if ( !g_running )
                 return -1;
-            if (( s_pChildStatus )&&( s_pChildStatus->m_iKillSent ))
-                return -1;
+            if (s_req_processed && s_worker_status
+                && s_worker_status->m_iKillSent)
+                return -1;
             FD_ZERO( &readfds );
             FD_SET( fd, &readfds );
             timeout.tv_sec = 1;
             timeout.tv_usec = 0;
+            if (fd == pReq->m_fdListen)
+            {
+                if (s_worker_status)
+                    __sync_lock_test_and_set(&s_worker_status->m_state,
+                                             LSAPI_STATE_ACCEPTING);
+                if (s_accepting_workers)
+                    __sync_fetch_and_add(s_accepting_workers, 1);
+            }
             ret = (*g_fnSelect)(fd+1, &readfds, NULL, NULL, &timeout);
+            if (fd == pReq->m_fdListen)
+            {
+                if (s_accepting_workers)
+                    __sync_fetch_and_sub(s_accepting_workers, 1);
+                if (s_worker_status)
+                    __sync_lock_test_and_set(&s_worker_status->m_state,
+                                             LSAPI_STATE_IDLE);
+            }
             if ( ret == 0 )
             {
-                if ( s_pChildStatus )
+                if ( s_worker_status )
                 {
-                    s_pChildStatus->m_inProcess = 0;
+                    s_worker_status->m_inProcess = 0;
+                    if (fd == pReq->m_fdListen
+                        && (s_keepListener != 2 || !is_enough_free_mem()))
+                        return -1;
                 }
                 ++wait_secs;
                 if (( s_max_idle_secs > 0 )&&(wait_secs >= s_max_idle_secs ))
                     return -1;
-                if ( s_ppid &&( getppid() != s_ppid))
+                if ( lsapi_parent_dead() )
                     return -1;
             }
             else if ( ret == -1 )
@@ -2836,17 +3621,25 @@ int LSAPI_Prefork_Accept_r( LSAPI_Request * pReq )
             }
             else if ( ret >= 1 )
             {
-                if (( s_pChildStatus )&&( s_pChildStatus->m_iKillSent ))
-                    return -1;
+                if (s_req_processed && s_worker_status
+                    && s_worker_status->m_iKillSent)
+                    return -1;
                 if ( fd == pReq->m_fdListen )
                 {
                     pReq->m_fd = lsapi_accept( pReq->m_fdListen );
                     if ( pReq->m_fd != -1 )
                     {
+                        if (s_worker_status)
+                            __sync_lock_test_and_set(&s_worker_status->m_state,
+                                                     LSAPI_STATE_CONNECTED);
+                        if (s_busy_workers)
+                            __sync_fetch_and_add(s_busy_workers, 1);
                         fd = pReq->m_fd;
                         lsapi_set_nblock( fd, 0 );
                         //init_conn_key( pReq->m_fd );
-                        if ( !s_keepListener )
+                        if (!s_keepListener)
                         {
                             close( pReq->m_fdListen );
                             pReq->m_fdListen = -1;
@@ -2859,7 +3652,7 @@ int LSAPI_Prefork_Accept_r( LSAPI_Request * pReq )
                     {
                         if (( errno == EINTR )||( errno == EAGAIN))
                             continue;
-                        lsapi_error( "lsapi_accept() error", errno );
+                        lsapi_perror( "lsapi_accept() error", errno );
                         return -1;
                     }
                 }
@@ -2870,42 +3663,46 @@ int LSAPI_Prefork_Accept_r( LSAPI_Request * pReq )
         if ( !readReq( pReq ) )
         {
-            if ( s_pChildStatus )
+            if ( s_worker_status )
             {
-                s_pChildStatus->m_iKillSent = 0;
-                s_pChildStatus->m_inProcess = 1;
-                ++s_pChildStatus->m_iReqCounter;
-                s_pChildStatus->m_tmReqBegin = s_pChildStatus->m_tmLastCheckPoint = time(NULL);
+                s_worker_status->m_iKillSent = 0;
+                s_worker_status->m_inProcess = 1;
+                ++s_worker_status->m_iReqCounter;
+                s_worker_status->m_tmReqBegin =
+                s_worker_status->m_tmLastCheckPoint = time(NULL);
             }
             ++s_req_processed;
             return 0;
         }
-        lsapi_close( pReq->m_fd );
-        pReq->m_fd = -1;
+        lsapi_close_connection(pReq);
         LSAPI_Reset_r( pReq );
     }
     return -1;
 }
 void LSAPI_Set_Max_Reqs( int reqs )
-{   s_max_reqs = reqs;          }
+{   s_max_reqs = reqs - 1;      }
 void LSAPI_Set_Max_Idle( int secs )
 {   s_max_idle_secs = secs;     }
 void LSAPI_Set_Max_Children( int maxChildren )
 {
     if ( g_prefork_server )
         g_prefork_server->m_iMaxChildren = maxChildren;
 }
 void LSAPI_Set_Extra_Children( int extraChildren )
 {
     if (( g_prefork_server )&&( extraChildren >= 0 ))
         g_prefork_server->m_iExtraChildren = extraChildren;
 }
 void LSAPI_Set_Max_Process_Time( int secs )
 {
     if (( g_prefork_server )&&( secs > 0 ))
@@ -2919,34 +3716,44 @@ void LSAPI_Set_Max_Idle_Children( int maxIdleChld )
         g_prefork_server->m_iMaxIdleChildren = maxIdleChld;
 }
 void LSAPI_Set_Server_Max_Idle_Secs( int serverMaxIdle )
 {
     if ( g_prefork_server )
         g_prefork_server->m_iServerMaxIdle = serverMaxIdle;
 }
 void LSAPI_Set_Slow_Req_Msecs( int msecs )
 {
     s_slow_req_msecs = msecs;
 }
-int  LSAPI_Get_Slow_Req_Msecs()
+int  LSAPI_Get_Slow_Req_Msecs(void)
 {
     return s_slow_req_msecs;
 }
-void LSAPI_No_Check_ppid()
+void LSAPI_No_Check_ppid(void)
 {
     s_ppid = 0;
 }
+int LSAPI_Get_ppid()
+{
+    return(s_ppid);
+}
 #if defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)
 #include <crt_externs.h>
 #else
 extern char ** environ;
 #endif
-static void unset_lsapi_envs()
+static void unset_lsapi_envs(void)
 {
     char **env;
 #if defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)
@@ -2954,26 +3761,162 @@ static void unset_lsapi_envs()
 #else
     env = environ;
 #endif
-    while( env != NULL && *env != NULL )
+    while( env != NULL && *env != NULL )
     {
-        if (!strncmp(*env, "LSAPI_", 6) || !strncmp( *env, "PHP_LSAPI_", 10 )
-            || (!strncmp( *env, "PHPRC=", 6 )&&(!s_uid)))
-        {
+        if (!strncmp(*env, "LSAPI_", 6) || !strncmp( *env, "PHP_LSAPI_", 10 )
+            || (!strncmp( *env, "PHPRC=", 6 )&&(!s_uid)))
+        {
             char ** del = env;
-            do
+            do
                 *del = del[1];
             while( *del++ );
         }
         else
             ++env;
-    }
+    }
+}
+static int lsapi_initSuEXEC(void)
+{
+    int i;
+    struct passwd * pw;
+    s_defaultUid = 0;
+    s_defaultGid = 0;
+    if ( s_uid == 0 )
+    {
+        const char * p = getenv( "LSAPI_DEFAULT_UID" );
+        if ( p )
+        {
+            i = atoi( p );
+            if ( i > 0 )
+                s_defaultUid = i;
+        }
+        p = getenv( "LSAPI_DEFAULT_GID" );
+        if ( p )
+        {
+            i = atoi( p );
+            if ( i > 0 )
+                s_defaultGid = i;
+        }
+        p = getenv( "LSAPI_SECRET" );
+        if (( !p )||( readSecret(p) == -1 ))
+                return -1;
+        if ( g_prefork_server )
+        {
+            if ( g_prefork_server->m_iMaxChildren < 100 )
+                g_prefork_server->m_iMaxChildren = 100;
+            if ( g_prefork_server->m_iExtraChildren < 1000 )
+                g_prefork_server->m_iExtraChildren = 1000;
+        }
+    }
+    if ( !s_defaultUid || !s_defaultGid )
+    {
+        pw = getpwnam( "nobody" );
+        if ( pw )
+        {
+            if ( !s_defaultUid )
+                s_defaultUid = pw->pw_uid;
+            if ( !s_defaultGid )
+                s_defaultGid = pw->pw_gid;
+        }
+        else
+        {
+            if ( !s_defaultUid )
+                s_defaultUid = 10000;
+            if ( !s_defaultGid )
+                s_defaultGid = 10000;
+        }
+    }
+    return 0;
+}
+static int lsapi_check_path(const char *p, char *final, int max_len)
+{
+    char resolved_path[PATH_MAX+1];
+    int len = 0;
+    char *end;
+    if (*p != '/')
+    {
+        if (getcwd(final, max_len) == NULL)
+            return -1;
+        len = strlen(final);
+        *(final + len) = '/';
+        ++len;
+    }
+    end = memccpy(&final[len], p, '\0', PATH_MAX - len);
+    if (!end)
+    {
+        errno = EINVAL;
+        return -1;
+    }
+    p = final;
+    if (realpath(p, resolved_path) == NULL
+        && errno != ENOENT && errno != EACCES)
+        return -1;
+    if (strncmp(resolved_path, "/etc/", 5) == 0)
+    {
+        errno = EPERM;
+        return -1;
+    }
+    return 0;
+}
+static int lsapi_reopen_stderr2(const char *full_path)
+{
+    int newfd = open(full_path, O_WRONLY | O_CREAT | O_APPEND, 0644);
+    if (newfd == -1)
+    {
+        LSAPI_perror_r(NULL, "Failed to open custom stderr log", full_path);
+        return -1;
+    }
+    if (newfd != 2)
+    {
+        dup2(newfd, 2);
+        close(newfd);
+        dup2(2, 1);
+    }
+    if (s_stderr_log_path && full_path != s_stderr_log_path)
+    {
+        free(s_stderr_log_path);
+        s_stderr_log_path = NULL;
+    }
+    s_stderr_log_path = strdup(full_path);
+    return 0;
+}
+static int lsapi_reopen_stderr(const char *p)
+{
+    char full_path[PATH_MAX];
+    if (s_uid == 0)
+        return -1;
+    if (lsapi_check_path(p, full_path, PATH_MAX) == -1)
+    {
+        LSAPI_perror_r(NULL, "Invalid custom stderr log path", p);
+        return -1;
+    }
+    return lsapi_reopen_stderr2(full_path);
 }
 int LSAPI_Init_Env_Parameters( fn_select_t fp )
 {
     const char *p;
+    char ch;
     int n;
     int avoidFork = 0;
+    p = getenv("LSAPI_STDERR_LOG");
+    if (p)
+    {
+        lsapi_reopen_stderr(p);
+    }
+    if (!s_stderr_log_path)
+        s_stderr_is_pipe = isPipe(STDERR_FILENO);
     p = getenv( "PHP_LSAPI_MAX_REQUESTS" );
     if ( !p )
         p = getenv( "LSAPI_MAX_REQS" );
@@ -2984,11 +3927,29 @@ int LSAPI_Init_Env_Parameters( fn_select_t fp )
             LSAPI_Set_Max_Reqs( n );
     }
+    p = getenv( "LSAPI_KEEP_LISTEN" );
+    if ( p )
+    {
+        n = atoi( p );
+        s_keepListener = n;
+    }
     p = getenv( "LSAPI_AVOID_FORK" );
     if ( p )
     {
         avoidFork = atoi( p );
-    }
+        if (avoidFork)
+        {
+            s_keepListener = 2;
+            ch = *(p + strlen(p) - 1);
+            if (  ch == 'G' || ch == 'g' )
+                avoidFork *= 1024 * 1024 * 1024;
+            else if (  ch == 'M' || ch == 'm' )
+                avoidFork *= 1024 * 1024;
+            if (avoidFork >= 1024 * 10240)
+                s_min_avail_pages = avoidFork / 4096;
+        }
+    }
     p = getenv( "LSAPI_ACCEPT_NOTIFY" );
     if ( p )
@@ -2997,7 +3958,7 @@ int LSAPI_Init_Env_Parameters( fn_select_t fp )
     }
     p = getenv( "LSAPI_SLOW_REQ_MSECS" );
-    if ( p )
+    if ( p )
     {
         n = atoi( p );
         LSAPI_Set_Slow_Req_Msecs( n );
@@ -3022,14 +3983,6 @@ int LSAPI_Init_Env_Parameters( fn_select_t fp )
         LSAPI_Set_Max_Idle( n );
     }
-    p = getenv( "LSAPI_KEEP_LISTEN" );
-    if ( p )
-    {
-        n = atoi( p );
-        s_keepListener = n;
-    }
     if ( LSAPI_Is_Listen() )
     {
         n = 0;
@@ -3040,33 +3993,43 @@ int LSAPI_Init_Env_Parameters( fn_select_t fp )
             n = atoi( p );
         if ( n > 1 )
         {
-            LSAPI_Init_Prefork_Server( n, fp, avoidFork );
+            LSAPI_Init_Prefork_Server( n, fp, avoidFork != 0 );
             LSAPI_Set_Server_fd( g_req.m_fdListen );
         }
         p = getenv( "LSAPI_EXTRA_CHILDREN" );
         if ( p )
             LSAPI_Set_Extra_Children( atoi( p ) );
         p = getenv( "LSAPI_MAX_IDLE_CHILDREN" );
         if ( p )
             LSAPI_Set_Max_Idle_Children( atoi( p ) );
         p = getenv( "LSAPI_PGRP_MAX_IDLE" );
         if ( p )
         {
             LSAPI_Set_Server_Max_Idle_Secs( atoi( p ) );
         }
         p = getenv( "LSAPI_MAX_PROCESS_TIME" );
-        if ( p )
+        if ( p )
             LSAPI_Set_Max_Process_Time( atoi( p ) );
         if ( getenv( "LSAPI_PPID_NO_CHECK" ) )
         {
             LSAPI_No_Check_ppid();
         }
+        p = getenv("LSAPI_MAX_BUSY_WORKER");
+        if (p)
+        {
+            n = atoi(p);
+            s_max_busy_workers = n;
+            if (n >= 0)
+                LSAPI_No_Check_ppid();
+        }
         p = getenv( "LSAPI_DUMP_DEBUG_INFO" );
         if ( p )
             s_dump_debug_info = atoi( p );
@@ -3082,7 +4045,25 @@ int LSAPI_Init_Env_Parameters( fn_select_t fp )
 }
+int LSAPI_ErrResponse_r( LSAPI_Request * pReq, int code, const char ** pRespHeaders,
+                         const char * pBody, int bodyLen )
+{
+    LSAPI_SetRespStatus_r( pReq, code );
+    if ( pRespHeaders )
+    {
+        while( *pRespHeaders )
+        {
+            LSAPI_AppendRespHeader_r( pReq, *pRespHeaders, strlen( *pRespHeaders ) );
+            ++pRespHeaders;
+        }
+    }
+    if ( pBody &&( bodyLen > 0 ))
+    {
+        LSAPI_Write_r( pReq, pBody, bodyLen );
+    }
+    LSAPI_Finish_r( pReq );
+    return 0;
+}
 static void lsapi_MD5Transform(uint32 buf[4], uint32 const in[16]);
@@ -3101,6 +4082,7 @@ static void byteReverse(unsigned char *buf, unsigned longs)
     } while (--longs);
 }
 /*
  * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
  * initialization constants.
@@ -3164,6 +4146,7 @@ void lsapi_MD5Update(struct lsapi_MD5Context *ctx, unsigned char const *buf, uns
     memmove(ctx->in, buf, len);
 }
 /*
  * Final wrapup - pad to 64-byte boundary with the bit pattern
  * 1 0* (64-bit count of bits processed, MSB-first)
@@ -3206,9 +4189,10 @@ void lsapi_MD5Final(unsigned char digest[16], struct lsapi_MD5Context *ctx)
     lsapi_MD5Transform(ctx->buf, (uint32 *) ctx->in);
     byteReverse((unsigned char *) ctx->buf, 4);
     memmove(digest, ctx->buf, 16);
-    memset(ctx, 0, sizeof(ctx));        /* In case it's sensitive */
+    memset(ctx, 0, sizeof(*ctx));        /* In case it's sensitive */
 }
 /* The four core functions - F1 is optimized somewhat */
 /* #define F1(x, y, z) (x & y | ~x & z) */
@@ -3309,3 +4293,18 @@ static void lsapi_MD5Transform(uint32 buf[4], uint32 const in[16])
     buf[3] += d;
 }
+int LSAPI_Set_Restored_Parent_Pid(int pid)
+{
+    int old_ppid = s_ppid;
+    s_restored_ppid = pid;
+    return old_ppid;
+}
+int LSAPI_Inc_Req_Processed(int cnt)
+{
+    return __sync_add_and_fetch(s_global_counter, cnt);
+}