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

ruby-lsapi 4.1 → 5.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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);
+}