ruby-lsapi 1.13 → 2.0

data/README

@@ -2,8 +2,6 @@
 lsapi - LSAPI extension for Ruby
 ================================
 
-Version 1.4
-
 INSTALL
 -------
 
@@ -15,7 +13,7 @@ USAGE
 -----
 
 General CGI scripts
-```````````````````
+^^^^^^^^^^^^^^^^^^^
 The most efficient way to use LSAPI interface is to modify your CGI scripts. 
 You need to add the following code to your CGI scripts:
 
@@ -34,51 +32,89 @@ are being accessed in your scripts.
 You can find some examples under examples/ folder.
 
 
+Ruby Script Runner
+^^^^^^^^^^^^^^^^^^
+If you don't want to change your existing Ruby CGI code, you can use our 
+Ruby script runner under scripts/ folder. You need to configure 
+lsruby_runner.rb as a LSAPI application, then add a script handler 
+for "rb" suffix.
+
+
+
 Rails dispatcher
-````````````````
-A LSAPI dispatcher is available under rails/ folder, just copy it over to  
-the public/ folder of your Rails application, then change the rewrite rule 
-in public/.htaccess from 
+^^^^^^^^^^^^^^^^
 
-    RewriteRule ^(.*)$ dispatch.fcgi [QSA,L]
-to
-    RewriteRule ^(.*)$ dispatch.lsapi [QSA,L]
+With Ruby LSAPI, we proudly provide a optimum platform for Rails application
+deployment. Ruby LSAPI has the following advantages over other solutions.
 
-It is very expensive to start a fresh Rails application process, and on
-the other hand, server hardware resources can be used more efficiently with
-dynamic spawning. In order to solve this problem, instead of spawning a
-fresh Rails process, LSAPI dispatcher will dynamically fork children processes
-off an initialized Rails process.
+  * Easy configuration, deploy a Rails application only take a few clicks
+    with our Rails easy configuration
+  * Fast startup, the expensive Rails framework initialization only takes
+    place once when multiple processes need to be started
+  * Resource efficience, ruby processes can be started on demand, idle
+    process will be stop.
+    
+To use LSAPI with Ruby on Rails, please check out our toturial
+http://www.litespeedtech.com/support/wiki/doku.php
 
-When you configure dispatch.lsapi as a LSAPI application, you should add
-an extra environment variable
+There are a few environment variables that can be tweaked to tune ruby 
+LSAPI process.
 
-    LSAPI_CHILDREN=n
+* LSAPI_CHILDREN                (default: 0)
 
-n should match the "Max Conns" configuration entry of the LSAPI application. 
+LSAPI_CHILDREN controls the maximum number of children processes can be
+started by the first ruby process started by web server. When set to <=1,
+the first ruby process will handle request by itself, without starting any
+child process. When LSAPI_CHILDREN is >1, the LSAPI application is stared in
+"Self Managed Mode", which will start children processes based on demand.
+With Rails easy configuration, LSAPI_CHILDREN is set to the value of
+"Max Connections" by web server, no need to set it explicitly.
 
-Two new environment variables has been introduced since Ruby LSAPI 1.4:
+Usually, there is no need to set value of LSAPI_CHILDREN over 100 in most
+server environment. 
 
-    LSAPI_MAX_REQS=n
 
-n is the maximum number of requests that a child process can serve. Default
-value is 1,000,000. Once that number is reached, the child process will exit
-automatically. This will help in case of any memory leaks in Rails. 
+* LSAPI_MAX_REQUESTS            (default value: 10000)
 
-    LSAPI_MAX_IDLE=n
+LSAPI_MAX_REQUESTS specifies the maximum number of requests each child
+process will handle before it exits automatically. This parameter can
+help reducing memory usage when there are memory leaks in the application. 
 
-n is the maximum idle time in seconds that a child process will be waiting 
-for a new request. Once it is reached, the child process will quit. 
-Default value is 60. When n <= 0, the child process will wait indefinitely. 
-This option helps getting rid of idle children processes.
+* LSAPI_MAX_IDLE   (default value: 300 seconds)
 
+In Self Managed Mode, LSAPI_MAX_IDLE controls how long a idle child  
+process will wait for a new request before exit. This option help 
+releasing system resources taken by idle processes.
 
-Ruby Script Runner
-``````````````````
-If you don't want to change your existing Ruby CGI code, you can use our 
-Ruby script runner under scripts/ folder. You need to configure 
-lsruby_runner.rb as a LSAPI application, then add a script handler 
-for "rb" suffix.
+* LSAPI_MAX_IDLE_CHILDREN  (default value: 1/3 of LSAPI_CHILDREN)
+
+In Self Managed Mode, LSAI_MAX_IDLE_CHILDREN controls how many idle 
+children processes are allowed. Excessive idle children processes
+will be killed by the parent process.
+
+* LSAPI_MAX_PROCESS_TIME   (default value: 300 seconds)
+
+In Self Managed Mode, LSAPI_MAX_PROCESS_TIME controls the maximum 
+processing time allowed when processing a request. If a child process
+can not finish processing of a request in the given time period, it 
+will be killed by the parent process. This option can help getting rid 
+of dead or runaway child process.
+
+* LSAPI_PGRP_MAX_IDLE      (default value: FOREVER )
+
+In Self Managed Mode, LSAPI_PGRP_MAX_IDLE controls how long the parent
+process will wait before exiting when there is no child process.
+This option help releasing system resources taken by an idle parent 
+process.
+
+* LSAPI_PPID_NO_CHECK
+
+By default a LSAPI application check the existence of its parent process
+and exits automatically if the parent process died. This is to reduce 
+orphan process when web server is restarted. However, it is desireable 
+to disable this feature, such as when a LSAPI process was started 
+manually from command line. LSAPI_PPID_NO_CHECK should be set when 
+you want to disable the checking of existence of parent process.
 
 
 License

data/ext/lsapi/lsapilib.c

@@ -45,16 +45,20 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <errno.h>
 #include <fcntl.h>
 
-//#include <arpa/inet.h>
-#include <sys/types.h>
+#include <arpa/inet.h>
+#include <netdb.h>
 #include <netinet/in.h>
 #include <netinet/tcp.h>
+#include <sys/un.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
+#include <sys/mman.h>
 #include <sys/socket.h>
 #include <sys/uio.h>
+#include <sys/wait.h>
+#include <time.h>
 #include <unistd.h>
 
 #define LSAPI_ST_REQ_HEADER     1
@@ -68,6 +72,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 static int g_inited = 0;
 static int g_running = 1;
+static int s_ppid;
 LSAPI_Request g_req;
 
 void Flush_RespBuf_r( LSAPI_Request * pReq );
@@ -545,6 +550,7 @@ int LSAPI_Init(void)
         if ( LSAPI_InitRequest( &g_req, LSAPI_SOCK_FILENO ) == -1 )
             return -1;
         g_inited = 1;
+        s_ppid = getppid();
     }
     return 0;
 }
@@ -859,7 +865,7 @@ int LSAPI_Write_r( LSAPI_Request * pReq, const char * pBuf, int len )
     int toWrite;
     int packetLen;
     
-    if ( !pReq || !pBuf )
+    if ( !pReq || !pBuf || (pReq->m_fd == -1) )
         return -1;
     if ( len < pReq->m_pRespBufEnd - pReq->m_pRespBufPos )
     {
@@ -958,6 +964,13 @@ int LSAPI_Flush_r( LSAPI_Request * pReq )
     n = pReq->m_pIovecCur - pReq->m_pIovecToWrite;
     if (( 0 == n )&&( pReq->m_pRespBufPos == pReq->m_pRespBuf ))
         return 0;
+    if ( pReq->m_fd == -1 )
+    {
+        pReq->m_pRespBufPos = pReq->m_pRespBuf;
+        pReq->m_totalLen = 0;
+        pReq->m_pIovecCur = pReq->m_pIovecToWrite = pReq->m_pIovec;
+        return -1;
+    }
     if ( pReq->m_reqState & LSAPI_ST_RESP_HEADER )
     {
         LSAPI_FinalizeRespHeaders_r( pReq );
@@ -997,6 +1010,8 @@ int LSAPI_Write_Stderr_r( LSAPI_Request * pReq, const char * pBuf, int len )
     struct iovec iov[2];
     struct iovec *pIov;
     
+    if (( !pReq )||( pReq->m_fd == -1 ))
+        return -1;
     if ( pReq->m_pRespBufPos != pReq->m_pRespBuf )
     {
         LSAPI_Flush_r( pReq );
@@ -1050,7 +1065,7 @@ static char * GetHeaderVar( LSAPI_Request * pReq, const char * name )
     {
         const char *p;
         char *pKey;
-        char *pKeyEnd ;
+        char *pKeyEnd;
         int  keyLen;
         struct lsapi_header_offset * pCur, *pEnd;
         pCur = pReq->m_pUnknownHeader;
@@ -1272,7 +1287,717 @@ int LSAPI_AppendRespHeader_r( LSAPI_Request * pReq, char * pBuf, int len )
 }
 
 
+int LSAPI_CreateListenSock2( const struct sockaddr * pServerAddr, int backlog )
+{
+    int ret;
+    int fd;
+    int flag = 1;
+    int addr_len;
+
+    switch( pServerAddr->sa_family )
+    {
+    case AF_INET:
+        addr_len = 16;
+        break;
+    case AF_INET6:
+        addr_len = sizeof( struct sockaddr_in6 );
+        break;
+    case AF_UNIX:
+        addr_len = sizeof( struct sockaddr_un );
+        unlink( ((struct sockaddr_un *)pServerAddr)->sun_path );
+        break;
+    default:
+        return -1;
+    }
+
+    fd = socket( pServerAddr->sa_family, SOCK_STREAM, 0 );
+    if ( fd == -1 )
+        return -1;
+
+    fcntl( fd, F_SETFD, FD_CLOEXEC );
+
+    if(setsockopt( fd, SOL_SOCKET, SO_REUSEADDR,
+                (char *)( &flag ), sizeof(flag)) == 0)
+    {
+        ret = bind( fd, pServerAddr, addr_len );
+        if ( !ret )
+        {
+            ret = listen( fd, backlog );
+            if ( !ret )
+                return fd;
+        }
+    }
+
+    ret = errno;
+    close(fd);
+    errno = ret;
+    return -1;
+
+}
+
+int LSAPI_ParseSockAddr( const char * pBind, struct sockaddr * pAddr )
+{
+    char achAddr[256];
+    char * p = achAddr;
+    char * pEnd;
+    struct addrinfo *res, hints;
+    int  doAddrInfo = 0;
+    int port;
+    
+    if ( !pBind )
+        return -1;
+
+    while( isspace( *p ) )
+        ++pBind;
+
+    strncpy( achAddr, pBind, 256 );
+
+    switch( *p )
+    {
+    case '/':
+        pAddr->sa_family = AF_UNIX;
+        strncpy( ((struct sockaddr_un *)pAddr)->sun_path, p,
+                sizeof(((struct sockaddr_un *)pAddr)->sun_path) );
+        return 0;
+
+    case '[':
+        pAddr->sa_family = AF_INET6;
+        ++p;
+        pEnd = strchr( p, ']' );
+        if ( !pEnd )
+            return -1;
+        *pEnd++ = 0;
+        
+        if ( *p == '*' )
+        {
+            strcpy( achAddr, "::" );
+            p = achAddr;
+        }
+        doAddrInfo = 1;
+        break;
+
+    default:
+        pAddr->sa_family = AF_INET;
+        pEnd = strchr( p, ':' );
+        if ( !pEnd )
+            return -1;
+        *pEnd++ = 0;
+        
+        doAddrInfo = 0;
+        if ( *p == '*' )
+        {
+            ((struct sockaddr_in *)pAddr)->sin_addr.s_addr = htonl(INADDR_ANY);
+        }
+        else if (!strcasecmp( p, "localhost" ) )
+            ((struct sockaddr_in *)pAddr)->sin_addr.s_addr = htonl( INADDR_LOOPBACK );
+        else
+        {
+            ((struct sockaddr_in *)pAddr)->sin_addr.s_addr = inet_addr( p );
+            if ( ((struct sockaddr_in *)pAddr)->sin_addr.s_addr == INADDR_BROADCAST)
+            {
+                doAddrInfo = 1;
+            }
+        }
+        break;
+    }
+    if ( *pEnd == ':' )
+        ++pEnd;
+        
+    port = atoi( pEnd );
+    if (( port <= 0 )||( port > 655535 ))
+        return -1;
+    if ( doAddrInfo )
+    {
+
+        memset(&hints, 0, sizeof(hints));
+
+        hints.ai_family   = pAddr->sa_family;
+        hints.ai_socktype = SOCK_STREAM;
+        hints.ai_protocol = IPPROTO_TCP;
+
+        if ( getaddrinfo(p, NULL, &hints, &res) )
+        {
+            return -1;
+        }
+
+        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];
+    int ret;
+    int fd = -1;
+    ret = LSAPI_ParseSockAddr( pBind, (struct sockaddr *)serverAddr );
+    if ( !ret )
+    {
+        fd = LSAPI_CreateListenSock2( (struct sockaddr *)serverAddr, backlog );
+    }
+    return fd;
+}
+
+static fn_select_t g_fnSelect = select;
+
+typedef struct _lsapi_child_status
+{
+    int     m_pid;
+    short   m_iKillSent;
+    volatile short   m_inProcess;
+    
+    volatile long    m_tmWaitBegin;
+    volatile long    m_tmReqBegin;
+    volatile long    m_tmLastCheckPoint;
+}
+lsapi_child_status;
+
+static lsapi_child_status * s_pChildStatus = NULL;
+
+typedef struct _lsapi_prefork_server
+{
+    int m_fd;
+    int m_iMaxChildren;
+    int m_iCurChildren;
+    int m_iMaxIdleChildren;
+    int m_iServerMaxIdle;
+    int m_iChildrenMaxIdleTime;
+    int m_iMaxReqProcessTime;
+    
+    lsapi_child_status * m_pChildrenStatus;
+    
+}lsapi_prefork_server;
+
+static lsapi_prefork_server * g_prefork_server = NULL;
+
+int LSAPI_Init_Prefork_Server( int max_children, fn_select_t fp )
+{
+    if ( g_prefork_server )
+        return 0;
+    if ( max_children <= 1 )
+        return -1;
+    if ( max_children >= 10000)
+        max_children = 10000;
+        
+    g_prefork_server = (lsapi_prefork_server *)malloc( sizeof( lsapi_prefork_server ) );
+    if ( !g_prefork_server )
+        return -1;
+    memset( g_prefork_server, 0, sizeof( lsapi_prefork_server ) );
+
+    if ( fp != NULL )
+        g_fnSelect = fp;
+
+    s_ppid = getppid();
+    g_prefork_server->m_iMaxChildren = max_children;
+    g_prefork_server->m_iMaxIdleChildren = max_children / 3;
+    g_prefork_server->m_iChildrenMaxIdleTime = 30;
+    g_prefork_server->m_iMaxReqProcessTime = 300;
+    return 0;    
+}
+
+void LSAPI_Set_Server_fd( int fd )
+{
+    if( g_prefork_server )
+        g_prefork_server->m_fd = fd;
+}
+
+
+static int lsapi_accept( int fdListen )
+{
+    int         fd;
+    int         nodelay = 1;
+    socklen_t   len;
+    char        achPeer[128];
+
+    len = sizeof( achPeer );
+    fd = accept( fdListen, (struct sockaddr *)&achPeer, &len );
+    if ( fd != -1 )
+    {
+        if (((struct sockaddr *)&achPeer)->sa_family == AF_INET )
+        {
+            setsockopt( fd, IPPROTO_TCP, TCP_NODELAY,
+                    (char *)&nodelay, sizeof(nodelay));
+        }
+    }
+    return fd;
+
+}
+
+
+
+
+static int s_req_processed = 0;
+static int s_max_reqs = 10000;
+static int s_max_idle_secs = 300;
+
+static int s_stop;
+
+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;
+    while( pStatus < pEnd )
+    {
+        if ( pStatus->m_pid == pid )
+            return pStatus;
+        ++pStatus;
+    }
+    return NULL;
+}
+
+
+
+static void lsapi_sigchild( int signal )
+{
+    int status, pid;
+    lsapi_child_status * child_status;
+    while( 1 )
+    {
+        pid = waitpid( -1, &status, WNOHANG|WUNTRACED );
+        if ( pid <= 0 )
+        {
+            break;
+        }
+        child_status = find_child_status( pid );
+        if ( child_status )
+            child_status->m_pid = 0;
+        --g_prefork_server->m_iCurChildren;
+    }
+
+}
+
+static int lsapi_init_children_status()
+{
+    int size = 4096;
+    
+    char * pBuf;
+    size = g_prefork_server->m_iMaxChildren * sizeof( lsapi_child_status ) * 2;
+    size = (size + 4095 ) / 4096 * 4096;
+    pBuf =( char*) mmap( NULL, size, PROT_READ | PROT_WRITE,
+        MAP_ANON | MAP_SHARED, -1, 0 );
+    if ( pBuf == MAP_FAILED )
+    {
+        perror( "Anonymous mmap() failed" );
+        return -1;
+    }
+    memset( pBuf, 0, size );
+    g_prefork_server->m_pChildrenStatus = (lsapi_child_status *)pBuf;	
+    return 0;
+}
+
+static void lsapi_check_child_status()
+{
+    int idle = 0;
+    int tobekilled;
+    long tmCur = time( NULL );
+    lsapi_child_status * pStatus = g_prefork_server->m_pChildrenStatus;
+    lsapi_child_status * pEnd = g_prefork_server->m_pChildrenStatus + g_prefork_server->m_iMaxChildren * 2;
+    while( pStatus < pEnd )
+    {
+        tobekilled = pStatus->m_iKillSent;
+        if ( pStatus->m_pid != 0 )
+        {
+            if ( !tobekilled )
+            {
+                if ( !pStatus->m_inProcess )
+                {
+                    if ( idle > g_prefork_server->m_iMaxIdleChildren )
+                    {
+                        tobekilled = 1;
+                    }
+                    else
+                    {
+                        if (( s_max_idle_secs> 0)&&(tmCur - pStatus->m_tmWaitBegin > s_max_idle_secs + 5 ))
+                            tobekilled = 1;
+                    }
+                    ++idle;
+                }
+                else
+                {
+                    if ( tmCur - pStatus->m_tmReqBegin > 
+                            g_prefork_server->m_iMaxReqProcessTime )
+                        tobekilled = 1;
+                }
+            }
+            if ( tobekilled )
+            {
+                tobekilled = 0;
+                if ( pStatus->m_iKillSent > 5 )
+                    tobekilled = SIGKILL;
+                else if ( pStatus->m_iKillSent == 2 )
+                    tobekilled = SIGTERM;
+                else if ( pStatus->m_iKillSent == 0 )
+                    tobekilled = SIGUSR1;
+                if ( tobekilled )
+                    kill( pStatus->m_pid, tobekilled );
+                ++pStatus->m_iKillSent;
+            }
+                
+        }
+        ++pStatus;
+    }
+}
+
+
+
+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;
+    lsapi_child_status * child_status;
+    int             wait_secs = 0;
+    int             ret;
+    int             pid;
+    fd_set          readfds;
+    struct timeval  timeout;
+
+    lsapi_init_children_status();
+    
+    setsid();
+
+    act.sa_flags = 0;
+    act.sa_handler = lsapi_sigchild;
+    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;
+    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;
+    while( !s_stop )
+    {
+        if ( pServer->m_iCurChildren >= (pServer->m_iMaxChildren << 1 ) )
+        {
+            usleep( 10000 );
+            continue;
+        }
+
+        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 )
+        {
+            if ( pServer->m_iCurChildren >= 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;
+            }
+        }
+        else if ( ret == -1 )
+        {
+            if ( errno == EINTR )
+                continue;
+            //perror( "select()" );
+            break;
+        }
+        else
+        {
+            if (s_ppid &&
+                (kill(s_ppid, 0) == -1)&&(errno == ESRCH))
+                break;
+            lsapi_check_child_status();
+            if (pServer->m_iServerMaxIdle)
+            {
+                if ( pServer->m_iCurChildren <= 0 )
+                {
+                    ++wait_secs;
+                    if ( wait_secs > pServer->m_iServerMaxIdle )
+                        return -1;
+                }
+                else
+                    wait_secs = 0;
+            }
+            continue;
+        }
+
+        pReq->m_fd = lsapi_accept( pServer->m_fd );
+        if ( pReq->m_fd != -1 )
+        {
+            child_status = find_child_status( 0 );
+            pid = fork();
+            if ( !pid )
+            {
+                g_prefork_server = NULL;
+                s_ppid = getppid();
+                s_req_processed = 0;
+                s_pChildStatus = child_status;
+                
+                /* don't catch our signals */
+                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 0;
+            }
+            else if ( pid == -1 )
+            {
+                perror( "fork() failed, please increase process limit" );
+            }
+            else
+            {
+                ++pServer->m_iCurChildren;
+                if ( child_status )
+                {
+                    child_status->m_pid = pid;
+                    child_status->m_iKillSent = 0;
+                    child_status->m_tmWaitBegin = time(NULL);
+                }
+            }
+            close( pReq->m_fd );
+            pReq->m_fd = -1;
+
+        }
+        else
+        {
+            if (( errno == EINTR )||( errno == EAGAIN))
+                continue;
+            perror( "accept() failed" );
+            return -1;
+        }
+    }
+    sigaction( SIGUSR1, &old_usr1, 0 );
+    kill( -getpgrp(), SIGUSR1 );
+    return -1;
+
+}
+
+int LSAPI_Prefork_Accept_r( LSAPI_Request * pReq )
+{
+    int             fd;
+    int             ret;
+    int             wait_secs;
+    fd_set          readfds;
+    struct timeval  timeout;
+
+    LSAPI_Finish_r( pReq );
+
 
+    if ( g_prefork_server )
+    {
+        if ( g_prefork_server->m_fd != -1 )
+            if ( lsapi_prefork_server_accept( g_prefork_server, pReq ) == -1 )
+                return -1;
+    }
+    if ( s_req_processed >= s_max_reqs )
+        return -1;
 
+    if ( s_pChildStatus )
+    {
+        s_pChildStatus->m_tmWaitBegin = time( NULL );
+    }
+    
+    while( g_running )
+    {
+        if ( pReq->m_fd != -1 )
+        {
+            fd = pReq->m_fd;
+        }
+        else if ( pReq->m_fdListen != -1 )
+            fd = pReq->m_fdListen;
+        else
+            return -1;
+        wait_secs = 0;
+        while( 1 )
+        {
+            if ( !g_running )
+                return -1;
+            FD_ZERO( &readfds );
+            FD_SET( fd, &readfds );
+            timeout.tv_sec = 1;
+            timeout.tv_usec = 0;
+            ret = (*g_fnSelect)(fd+1, &readfds, NULL, NULL, &timeout);
+            if ( ret == 0 )
+            {
+                if ( s_pChildStatus )
+                {
+                    s_pChildStatus->m_inProcess = 0;
+                }
+                ++wait_secs;
+                if (( s_max_idle_secs > 0 )&&(wait_secs >= s_max_idle_secs ))
+                    return -1;
+                if ( s_ppid &&(kill(s_ppid, 0) == -1)&&(errno == ESRCH))
+                    return -1;
+            }
+            else if ( ret == -1 )
+            {
+                if ( errno == EINTR )
+                    continue;
+                else
+                    return -1;
+            }
+            else if ( ret >= 1 )
+            {
+                if ( fd == pReq->m_fdListen )
+                {
+                    pReq->m_fd = lsapi_accept( pReq->m_fdListen );
+                    if ( pReq->m_fd != -1 )
+                    {
+                        fd = pReq->m_fd;
+                    }
+                    else
+                        return -1;
+                }
+                else
+                    break;
+            }
+        }
+
+        if ( !readReq( pReq ) )
+        {
+            if ( s_pChildStatus )
+            {
+                s_pChildStatus->m_inProcess = 1;
+                s_pChildStatus->m_tmReqBegin = s_pChildStatus->m_tmLastCheckPoint = time(NULL);
+            }
+            ++s_req_processed;
+            return 0;
+        }
+        lsapi_close( pReq->m_fd );
+        pReq->m_fd = -1;
+        LSAPI_Reset_r( pReq );
+    }
+    return -1;
+    
+}
+
+void LSAPI_Set_Max_Reqs( int reqs )
+{   s_max_reqs = reqs;          }
+
+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_Max_Process_Time( int secs )
+{
+    if (( g_prefork_server )&&( secs > 0 ))
+        g_prefork_server->m_iMaxReqProcessTime = secs;
+}
+
+
+void LSAPI_Set_Max_Idle_Children( int maxIdleChld )
+{
+    if (( g_prefork_server )&&( maxIdleChld > 0 ))
+        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_No_Check_ppid()
+{
+    s_ppid = 0;
+}
+
+extern char ** environ;
+static void unset_lsapi_envs()
+{
+    char **env = environ;
+    while( env != NULL && *env != NULL ) 
+    {
+        if (!strncmp(*env, "LSAPI_", 6) || !strncmp( *env, "PHP_LSAPI_", 10 ) ) 
+        {   
+            char ** del = env;
+            do 
+                *del = del[1];
+            while( *del++ );
+        }
+        else
+            ++env;
+    }  
+}
+
+void LSAPI_Init_Env_Parameters( fn_select_t fp )
+{
+    const char *p;
+    int n;
+    p = getenv( "PHP_LSAPI_MAX_REQUESTS" );
+    if ( !p )
+        p = getenv( "LSAPI_MAX_REQS" );
+    if ( p )
+    {
+        n = atoi( p );
+        if ( n > 0 )
+            LSAPI_Set_Max_Reqs( n );
+    }
+
+    p = getenv( "LSAPI_MAX_IDLE" );
+    if ( p )
+    {
+        n = atoi( p );
+        LSAPI_Set_Max_Idle( n );
+    }
+
+    if ( LSAPI_Is_Listen() )
+    {
+        n = 0;
+        p = getenv( "PHP_LSAPI_CHILDREN" );
+        if ( !p )
+            p = getenv( "LSAPI_CHILDREN" );
+        if ( p )
+            n = atoi( p );
+        if ( n > 1 )
+        {
+            LSAPI_Init_Prefork_Server( n, fp );
+            LSAPI_Set_Server_fd( g_req.m_fdListen );
+        }
+
+        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 )       
+            LSAPI_Set_Max_Process_Time( atoi( p ) );
+        
+        if ( getenv( "LSAPI_PPID_NO_CHECK" ) )
+        {
+            LSAPI_No_Check_ppid();
+        }
+    }
+    unset_lsapi_envs();
+}