ruby-lsapi 5.2 → 5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd8cc4083ffaa583379211d191ec387ebf69929bc27100fc0e6793a43186842b
-  data.tar.gz: d25c2dfd57b141aefedbe63d0c52c60c1bf634cf6b11876d191a8758368df4b0
+  metadata.gz: 0a220d3f4f42cb5d58212a8947a2650b1998d5dba3c8bddbd492dd5864be96bf
+  data.tar.gz: 42cd393c94027e4620c08d6d661bca16508036312099321c074ed6c788654d2c
 SHA512:
-  metadata.gz: d67f5730c65b2b42185450ffcdcb03203f5ba7952467b46cd82a6e60d530a0071b9ba22f42eee92d13adbe95d27aa705589386f2b12843a8bf4acd65c5a1c5ec
-  data.tar.gz: 418eef951b7d6c9880c1a7f89a64568d2073920e9edc6ba45c21c5d43278f23e8294a2062c22d28ac309f1e204924e722b32c722458991269b8ed3c192a65e4b
+  metadata.gz: b1af0f8254ac6a7c89077b89ee9176f9024f763c6102c20a5c3545127620fa06f05fb4fc4f4be3871721bf0d0bfd30ae2496b47d642f60c64cfb171f23aa6459
+  data.tar.gz: bf5f7cefabdbb163081d693a5dffc17a843b2764b1b3a7875fda53ae9c6cfe527c7a7a5eae52e9828a1ab9ffb3699cd7f0d2c8805710970dc63cee75fa75ae73

data/ext/lsapi/lsapilib.c

@@ -133,7 +133,7 @@ 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_keep_listener = 1;
 static int s_dump_debug_info = 0;
 static int s_pid_dump_debug_info = 0;
 static int s_req_processed = 0;
@@ -152,7 +152,7 @@ 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;
 
-LSAPI_Request g_req = 
+LSAPI_Request g_req =
 { .m_fdListen = -1, .m_fd = -1 };
 
 static char         s_secret[24];
@@ -215,7 +215,7 @@ static int HTTP_HEADER_LEN[H_TRANSFER_ENCODING+1] =
 };
 
 
-static const char *s_log_level_names[8] = 
+static const char *s_log_level_names[8] =
 {
     "", "DEBUG","INFO", "NOTICE", "WARN", "ERROR", "CRIT", "FATAL"
 };
@@ -229,7 +229,7 @@ void LSAPI_Log(int flag, const char * fmt, ...)
         && !(s_stderr_is_pipe))
     {
         struct timeval  tv;
-        struct tm       tm; 
+        struct tm       tm;
         gettimeofday(&tv, NULL);
         localtime_r(&tv.tv_sec, &tm);
         if (flag & LSAPI_LOG_TIMESTAMP_FULL)
@@ -244,18 +244,18 @@ void LSAPI_Log(int flag, const char * fmt, ...)
                 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;
@@ -342,6 +342,7 @@ static void lsapi_enable_core_dump(void)
     int  mib[2];
     size_t len;
 
+#if !defined(__OpenBSD__)
     len = 2;
     if ( sysctlnametomib("kern.sugid_coredump", mib, &len) == 0 )
     {
@@ -350,6 +351,15 @@ static void lsapi_enable_core_dump(void)
             perror( "sysctl: Failed to set 'kern.sugid_coredump', "
                     "core dump may not be available!");
     }
+#else
+    int set = 3;
+    len = sizeof(set);
+    mib[0] = CTL_KERN;
+    mib[1] = KERN_NOSUIDCOREDUMP;
+    if (sysctl(mib, 2, NULL, 0, &set, len) == 0) {
+        s_enable_core_dump = 1;
+    }
+#endif
 
 
 #endif
@@ -414,9 +424,10 @@ static void lsapi_close_connection(LSAPI_Request *pReq)
     lsapi_close(pReq->m_fd);
     pReq->m_fd = -1;
     if (s_busy_workers)
-        __sync_fetch_and_sub(s_busy_workers, 1);
+        __atomic_fetch_sub(s_busy_workers, 1, __ATOMIC_SEQ_CST);
     if (s_worker_status)
-        __sync_lock_test_and_set(&s_worker_status->m_state, LSAPI_STATE_IDLE);
+        __atomic_store_n(&s_worker_status->m_state, LSAPI_STATE_IDLE,
+                         __ATOMIC_SEQ_CST);
 }
 
 
@@ -720,8 +731,8 @@ static int validateHeaders( LSAPI_Request * pReq )
     {
         if ( pReq->m_pHeaderIndex->m_headerOff[i] )
         {
-            if (pReq->m_pHeaderIndex->m_headerOff[i] > totalLen 
-                || pReq->m_pHeaderIndex->m_headerLen[i] 
+            if (pReq->m_pHeaderIndex->m_headerOff[i] > totalLen
+                || pReq->m_pHeaderIndex->m_headerLen[i]
                     + pReq->m_pHeaderIndex->m_headerOff[i] > totalLen)
                 return -1;
         }
@@ -733,8 +744,8 @@ static int validateHeaders( LSAPI_Request * pReq )
         pEnd = pCur + pReq->m_pHeader->m_cntUnknownHeaders;
         while( pCur < pEnd )
         {
-            if (pCur->nameOff > totalLen 
-                || pCur->nameOff + pCur->nameLen > totalLen 
+            if (pCur->nameOff > totalLen
+                || pCur->nameOff + pCur->nameLen > totalLen
                 || pCur->valueOff > totalLen
                 || pCur->valueOff + pCur->valueLen > totalLen)
                 return -1;
@@ -893,6 +904,7 @@ static int LSAPI_perror_r( LSAPI_Request * pReq, const char * pErr1, const char
 }
 
 
+#if defined(linux) || defined(__linux) || defined(__linux__) || defined(__gnu_linux__)
 static int lsapi_lve_error( LSAPI_Request * pReq )
 {
     static const char * headers[] =
@@ -916,10 +928,8 @@ static int lsapi_lve_error( LSAPI_Request * pReq )
     return 0;
 }
 
-
 static int lsapi_enterLVE( LSAPI_Request * pReq, uid_t uid )
 {
-#if defined(linux) || defined(__linux) || defined(__linux__) || defined(__gnu_linux__)
     if ( s_lve && uid ) //root user should not do that
     {
         uint32_t cookie;
@@ -927,37 +937,32 @@ static int lsapi_enterLVE( LSAPI_Request * pReq, uid_t uid )
         ret = (*fp_lve_enter)(s_lve, uid, -1, -1, &cookie);
         if ( ret < 0 )
         {
-            //lsapi_log("enter LVE (%d) : ressult: %d !\n", uid, ret );
+            //lsapi_log("enter LVE (%d) : result: %d !\n", uid, ret );
             LSAPI_perror_r(pReq, "LSAPI: lve_enter() failure, reached resource limit.", NULL );
             lsapi_lve_error( pReq );
             return -1;
         }
     }
-#endif
 
     return 0;
 }
 
-
 static int lsapi_jailLVE( LSAPI_Request * pReq, uid_t uid, struct passwd * pw )
 {
     int ret = 0;
-#if defined(linux) || defined(__linux) || defined(__linux__) || defined(__gnu_linux__)
     char  error_msg[1024] = "";
     ret = (*fp_lve_jail)( pw, error_msg );
     if ( ret < 0 )
     {
-        lsapi_log("LSAPI: LVE jail(%d) ressult: %d, error: %s !\n",
+        lsapi_log("LSAPI: LVE jail(%d) result: %d, error: %s !\n",
                   uid, ret, error_msg );
         LSAPI_perror_r( pReq, "LSAPI: jail() failure.", NULL );
         return -1;
     }
-#endif
     return ret;
 }
 
 
-#if defined(linux) || defined(__linux) || defined(__linux__) || defined(__gnu_linux__)
 static int lsapi_initLVE(void)
 {
     const char * pEnv;
@@ -1207,13 +1212,13 @@ 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 
+    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 < 0
         || pReq->m_pHeader->m_requestMethodOff >= totalLen)
     {
         lsapi_log("Bad request header - ERROR#1\n");
@@ -1244,13 +1249,13 @@ static int parseRequest( LSAPI_Request * pReq, int totalLen )
     {
         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 )
     {
@@ -1271,7 +1276,7 @@ static struct lsapi_packet_header s_ack = {'L', 'S',
                 LSAPI_REQ_RECEIVED, LSAPI_ENDIAN, {LSAPI_PACKET_HEADER_LEN} };
 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 )
 {
@@ -1337,30 +1342,6 @@ static inline int lsapi_notify_pid( int fd )
     return 0;
 }
 
-
-static char s_conn_key_packet[16];
-static inline int init_conn_key( int fd )
-{
-    struct lsapi_packet_header * pHeader = (struct lsapi_packet_header *)s_conn_key_packet;
-    struct timeval tv;
-    int i;
-    gettimeofday( &tv, NULL );
-    srand( (tv.tv_sec % 0x1000 + tv.tv_usec) ^ rand() );
-    for( i = 8; i < 16; ++i )
-    {
-        s_conn_key_packet[i]=(int) (256.0*rand()/(RAND_MAX+1.0));
-    }
-    lsapi_buildPacketHeader( pHeader, LSAPI_REQ_RECEIVED,
-                        8 + LSAPI_PACKET_HEADER_LEN );
-    if ( write( fd, s_conn_key_packet, LSAPI_PACKET_HEADER_LEN+8 )
-                < LSAPI_PACKET_HEADER_LEN+8 )
-        return -1;
-    return 0;
-
-
-}
-
-
 static int readReq( LSAPI_Request * pReq )
 {
     int len;
@@ -1560,10 +1541,10 @@ 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);
+                        __atomic_store_n(&s_worker_status->m_state,
+                                       LSAPI_STATE_CONNECTED, __ATOMIC_SEQ_CST);
                     if (s_busy_workers)
-                        __sync_fetch_and_add(s_busy_workers, 1);
+                        __atomic_fetch_add(s_busy_workers, 1, __ATOMIC_SEQ_CST);
                     lsapi_set_nblock( pReq->m_fd , 0 );
                     if (((struct sockaddr *)&achPeer)->sa_family == AF_INET )
                     {
@@ -1695,10 +1676,10 @@ 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 
+    if ( *(pReq->m_pHttpHeader + off
         + pReq->m_pHeaderIndex->m_headerLen[ headerIndex ]) )
     {
-        *( pReq->m_pHttpHeader + off 
+        *( pReq->m_pHttpHeader + off
             + pReq->m_pHeaderIndex->m_headerLen[ headerIndex ]) = 0;
     }
     return pReq->m_pHttpHeader + off;
@@ -1927,7 +1908,7 @@ ssize_t LSAPI_Write_r( LSAPI_Request * pReq, const char * pBuf, size_t len )
 }
 
 
-#if defined(__FreeBSD__ ) || defined(__NetBSD__) || defined(__OpenBSD__)
+#if defined(__FreeBSD__ )
 ssize_t gsendfile( int fdOut, int fdIn, off_t* off, size_t size )
 {
     ssize_t ret;
@@ -1942,6 +1923,41 @@ ssize_t gsendfile( int fdOut, int fdIn, off_t* off, size_t size )
 }
 #endif
 
+#if defined(__OpenBSD__) || defined(__NetBSD__)
+ssize_t gsendfile( int fdOut, int fdIn, off_t* off, size_t size )
+{
+    ssize_t ret;
+    off_t written = 0;
+    const size_t bufsiz = 16384;
+    unsigned char in[bufsiz] = {0};
+
+    if (lseek(fdIn, *off, SEEK_SET) == -1) {
+        return -1;
+    }
+
+    while (size > 0) {
+        size_t tor = size > sizeof(in) ? sizeof(in) : size;
+        ssize_t c = read(fdIn, in, tor);
+        if (c <= 0) {
+            goto end;
+        }
+
+        ssize_t w = write(fdOut, in, c);
+        if (w > 0)
+            written += w;
+
+        if (w != c) {
+            goto end;
+        }
+        size -= c;
+    }
+
+end:
+    *off += written;
+    return 0;
+}
+#endif
+
 
 #if defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)
 ssize_t gsendfile( int fdOut, int fdIn, off_t* off, size_t size )
@@ -2152,7 +2168,7 @@ static char * GetHeaderVar( LSAPI_Request * pReq, const char * name )
         {
             if ( strcmp( name, CGI_HEADERS[i] ) == 0 )
             {
-                pValue = pReq->m_pHttpHeader 
+                pValue = pReq->m_pHttpHeader
                          + pReq->m_pHeaderIndex->m_headerOff[i];
                 if ( *(pValue + pReq->m_pHeaderIndex->m_headerLen[i]) != '\0')
                 {
@@ -2188,7 +2204,7 @@ static char * GetHeaderVar( LSAPI_Request * pReq, const char * name )
             if (( pKey == pKeyEnd )&& (!*p ))
             {
                 pValue = pReq->m_pHttpHeader + pCur->valueOff;
-                
+
                 if ( *(pValue + pCur->valueLen) != '\0')
                 {
                     *(pValue + pCur->valueLen) = '\0';
@@ -2655,8 +2671,12 @@ int LSAPI_ParseSockAddr( const char * pBind, struct sockaddr * pAddr )
             ((struct sockaddr_in *)pAddr)->sin_addr.s_addr = htonl( INADDR_LOOPBACK );
         else
         {
+#ifdef HAVE_INET_PTON
+            if (!inet_pton(AF_INET, p, &((struct sockaddr_in *)pAddr)->sin_addr))
+#else
             ((struct sockaddr_in *)pAddr)->sin_addr.s_addr = inet_addr( p );
             if ( ((struct sockaddr_in *)pAddr)->sin_addr.s_addr == INADDR_BROADCAST)
+#endif
             {
                 doAddrInfo = 1;
             }
@@ -2853,9 +2873,9 @@ void LSAPI_reset_server_state( void )
         ++pStatus;
     }
     if (s_busy_workers)
-        __sync_lock_release(s_busy_workers);
+        __atomic_store_n(s_busy_workers, 0, __ATOMIC_SEQ_CST);
     if (s_accepting_workers)
-        __sync_lock_release(s_accepting_workers);
+        __atomic_store_n(s_accepting_workers, 0, __ATOMIC_SEQ_CST);
 
 }
 
@@ -2863,8 +2883,10 @@ void LSAPI_reset_server_state( void )
 static void lsapi_sigchild( int signal )
 {
     int status, pid;
+    char expect_connected = LSAPI_STATE_CONNECTED;
+    char expect_accepting = LSAPI_STATE_ACCEPTING;
     lsapi_child_status * child_status;
-    if (g_prefork_server == NULL) 
+    if (g_prefork_server == NULL)
         return;
     while( 1 )
     {
@@ -2876,9 +2898,13 @@ static void lsapi_sigchild( int signal )
         if ( WIFSIGNALED( status ))
         {
             int sig_num = WTERMSIG( status );
-            int dump = WCOREDUMP( status );
+#ifdef WCOREDUMP
+            const char * dump = WCOREDUMP( status ) ? "yes" : "no";
+#else
+            const char * dump = "unknown";
+#endif
             lsapi_log("Child process with pid: %d was killed by signal: "
-                     "%d, core dump: %d\n", pid, sig_num, dump );
+                     "%d, core dumped: %s\n", pid, sig_num, dump );
         }
         if ( pid == s_pid_dump_debug_info )
         {
@@ -2894,19 +2920,23 @@ static void lsapi_sigchild( int signal )
         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 (__atomic_compare_exchange_n(&child_status->m_state,
+                                            &expect_connected,
+                                            LSAPI_STATE_IDLE, 1,
+                                            __ATOMIC_SEQ_CST,
+                                            __ATOMIC_SEQ_CST))
             {
                 if (s_busy_workers)
-                    __sync_fetch_and_sub(s_busy_workers, 1);
+                    __atomic_fetch_sub(s_busy_workers, 1, __ATOMIC_SEQ_CST);
             }
-            else if (__sync_bool_compare_and_swap(&child_status->m_state,
-                                                  LSAPI_STATE_ACCEPTING,
-                                                  LSAPI_STATE_IDLE))
+            else if (__atomic_compare_exchange_n(&child_status->m_state,
+                                                 &expect_accepting,
+                                                 LSAPI_STATE_IDLE, 1,
+                                                 __ATOMIC_SEQ_CST,
+                                                 __ATOMIC_SEQ_CST))
             {
                 if (s_accepting_workers)
-                    __sync_fetch_and_sub(s_accepting_workers, 1);
+                    __atomic_fetch_sub(s_accepting_workers, 1, __ATOMIC_SEQ_CST);
             }
             child_status->m_pid = 0;
             --g_prefork_server->m_iCurChildren;
@@ -2928,7 +2958,7 @@ static int lsapi_init_children_status(void)
         return 0;
     max_children = g_prefork_server->m_iMaxChildren
                         + g_prefork_server->m_iExtraChildren;
-    
+
     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,
@@ -2964,7 +2994,7 @@ static void dump_debug_info( lsapi_child_status * pStatus, long tmCur )
     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, 
+             pStatus->m_iReqCounter, tmCur - pStatus->m_tmReqBegin,
              tmCur - pStatus->m_tmLastCheckPoint, tmCur - pStatus->m_tmStart );
 
     s_pid_dump_debug_info = fork();
@@ -2996,9 +3026,8 @@ static void lsapi_check_child_status( long tmCur )
             ++count;
             if ( !pStatus->m_inProcess )
             {
-
-                if (g_prefork_server->m_iCurChildren - dying 
-                        > g_prefork_server->m_iMaxChildren 
+                if (g_prefork_server->m_iCurChildren - dying
+                        > g_prefork_server->m_iMaxChildren
                     || idle > g_prefork_server->m_iMaxIdleChildren)
                 {
                     ++pStatus->m_iKillSent;
@@ -3006,14 +3035,14 @@ static void lsapi_check_child_status( long tmCur )
                 }
                 else
                 {
-                    if (s_max_idle_secs> 0 
+                    if (s_max_idle_secs> 0
                         && tmCur - pStatus->m_tmWaitBegin > s_max_idle_secs + 5)
                     {
                         ++pStatus->m_iKillSent;
                         //tobekilled = SIGUSR1;
                     }
                 }
-                if ( !tobekilled )
+                if (!pStatus->m_iKillSent)
                     ++idle;
             }
             else
@@ -3039,7 +3068,7 @@ static void lsapi_check_child_status( long tmCur )
             }
             if ( tobekilled )
             {
-                if (( kill( pStatus->m_pid, tobekilled ) == -1 ) && 
+                if (( kill( pStatus->m_pid, tobekilled ) == -1 ) &&
                     ( errno == ESRCH ))
                 {
                     pStatus->m_pid = 0;
@@ -3083,11 +3112,11 @@ static void lsapi_check_child_status( long tmCur )
 //}
 
 
-void set_skip_write()
+void set_skip_write(void)
 {   s_skip_write = 1;   }
 
 
-int is_enough_free_mem()
+int is_enough_free_mem(void)
 {
 #if defined(linux) || defined(__linux) || defined(__linux__) || defined(__gnu_linux__)
     //minimum 1GB or 10% available free memory
@@ -3098,7 +3127,7 @@ int is_enough_free_mem()
 }
 
 
-static int lsapi_prefork_server_accept( lsapi_prefork_server * pServer, 
+static int lsapi_prefork_server_accept( lsapi_prefork_server * pServer,
                                         LSAPI_Request * pReq )
 {
     struct sigaction act, old_term, old_quit, old_int,
@@ -3173,19 +3202,19 @@ static int lsapi_prefork_server_accept( lsapi_prefork_server * pServer,
 #endif
         FD_ZERO( &readfds );
         FD_SET( pServer->m_fd, &readfds );
-        timeout.tv_sec = 1; 
+        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);
+                accepting = __atomic_load_n(s_accepting_workers, __ATOMIC_SEQ_CST);
 
             if (pServer->m_iCurChildren > 0
                 && accepting > 0)
             {
-                usleep( 400);
+                usleep(400);
                 while(accepting-- > 0)
                     sched_yield();
                 continue;
@@ -3203,13 +3232,13 @@ static int lsapi_prefork_server_accept( lsapi_prefork_server * pServer,
             continue;
         }
 
-        if (pServer->m_iCurChildren >= 
+        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, 
+                     pServer->m_iMaxChildren, pServer->m_iExtraChildren,
+                     pServer->m_iCurChildren,
                      s_busy_workers ? *s_busy_workers : -1 );
             usleep( 100000 );
             continue;
@@ -3246,16 +3275,16 @@ static int lsapi_prefork_server_accept( lsapi_prefork_server * pServer,
                 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);
+                __atomic_store_n(&s_worker_status->m_state,
+                                 LSAPI_STATE_CONNECTED, __ATOMIC_SEQ_CST);
                 if (s_busy_workers)
-                    __sync_add_and_fetch(s_busy_workers, 1);
+                    __atomic_add_fetch(s_busy_workers, 1, __ATOMIC_SEQ_CST);
                 lsapi_set_nblock( pReq->m_fd, 0 );
                 //keep it open if busy_count is used.
-                if (s_busy_workers
+                if (!s_keep_listener && s_busy_workers
                     && *s_busy_workers > (pServer->m_iMaxChildren >> 1))
-                    s_keepListener = 1;
-                if ((s_uid == 0 || !s_keepListener || !is_enough_free_mem())
+                    s_keep_listener = 1;
+                if ((s_uid == 0 || !s_keep_listener || !is_enough_free_mem())
                     && pReq->m_fdListen != -1 )
                 {
                     close( pReq->m_fdListen );
@@ -3321,7 +3350,7 @@ 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);
+    __atomic_store_n(&pReq->child_status->m_pid, s_pid, __ATOMIC_SEQ_CST);
     s_worker_status = pReq->child_status;
 
     setsid();
@@ -3333,16 +3362,16 @@ int LSAPI_Postfork_Child(LSAPI_Request * pReq)
     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);
+    __atomic_store_n(&s_worker_status->m_state,
+                     LSAPI_STATE_CONNECTED, __ATOMIC_SEQ_CST);
     if (s_busy_workers)
-        __sync_add_and_fetch(s_busy_workers, 1);
+        __atomic_add_fetch(s_busy_workers, 1, __ATOMIC_SEQ_CST);
     lsapi_set_nblock( pReq->m_fd, 0 );
     //keep it open if busy_count is used.
-    if (s_busy_workers
+    if (!s_keep_listener && s_busy_workers
         && *s_busy_workers > (max_children >> 1))
-        s_keepListener = 1;
-    if ((s_uid == 0 || !s_keepListener || !is_enough_free_mem())
+        s_keep_listener = 1;
+    if ((s_uid == 0 || !s_keep_listener || !is_enough_free_mem())
         && pReq->m_fdListen != -1 )
     {
         close(pReq->m_fdListen);
@@ -3453,7 +3482,7 @@ int LSAPI_Accept_Before_Fork(LSAPI_Request * pReq)
         {
             int accepting = 0;
             if (s_accepting_workers)
-                accepting = __sync_add_and_fetch(s_accepting_workers, 0);
+                accepting = __atomic_load_n(s_accepting_workers, __ATOMIC_SEQ_CST);
 
             if (pServer->m_iCurChildren > 0
                 && accepting > 0)
@@ -3538,14 +3567,14 @@ int LSAPI_Prefork_Accept_r( LSAPI_Request * pReq )
     }
     else if (s_req_processed > 0 && s_max_busy_workers > 0 && s_busy_workers)
     {
-        ret = __sync_fetch_and_add(s_busy_workers, 0);
+        ret = __atomic_load_n(s_busy_workers, __ATOMIC_SEQ_CST);
         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;
 
@@ -3572,7 +3601,7 @@ int LSAPI_Prefork_Accept_r( LSAPI_Request * pReq )
         {
             if ( !g_running )
                 return -1;
-            if (s_req_processed && s_worker_status 
+            if (s_req_processed && s_worker_status
                 && s_worker_status->m_iKillSent)
                 return -1;
             FD_ZERO( &readfds );
@@ -3582,29 +3611,41 @@ int LSAPI_Prefork_Accept_r( LSAPI_Request * pReq )
             if (fd == pReq->m_fdListen)
             {
                 if (s_worker_status)
-                    __sync_lock_test_and_set(&s_worker_status->m_state,
-                                             LSAPI_STATE_ACCEPTING);
+                    __atomic_store_n(&s_worker_status->m_state,
+                                     LSAPI_STATE_ACCEPTING, __ATOMIC_SEQ_CST);
                 if (s_accepting_workers)
-                    __sync_fetch_and_add(s_accepting_workers, 1);
+                    __atomic_fetch_add(s_accepting_workers, 1, __ATOMIC_SEQ_CST);
             }
             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);
+                    __atomic_fetch_sub(s_accepting_workers, 1, __ATOMIC_SEQ_CST);
                 if (s_worker_status)
-                    __sync_lock_test_and_set(&s_worker_status->m_state,
-                                             LSAPI_STATE_IDLE);
+                    __atomic_store_n(&s_worker_status->m_state,
+                                     LSAPI_STATE_IDLE, __ATOMIC_SEQ_CST);
             }
-            
+
             if ( ret == 0 )
             {
                 if ( s_worker_status )
                 {
                     s_worker_status->m_inProcess = 0;
-                    if (fd == pReq->m_fdListen
-                        && (s_keepListener != 2 || !is_enough_free_mem()))
-                        return -1;
+                    if (fd == pReq->m_fdListen)
+                    {
+                        if (s_keep_listener == 0 || !is_enough_free_mem())
+                            return -1;
+                        if (s_keep_listener == 1)
+                        {
+                            int wait_time = 10;
+                            if (s_busy_workers)
+                                wait_time += *s_busy_workers * 10;
+                            if (s_accepting_workers)
+                                wait_time >>= (*s_accepting_workers);
+                            if (wait_secs >= wait_time)
+                                return -1;
+                        }
+                    }
                 }
                 ++wait_secs;
                 if (( s_max_idle_secs > 0 )&&(wait_secs >= s_max_idle_secs ))
@@ -3621,7 +3662,7 @@ int LSAPI_Prefork_Accept_r( LSAPI_Request * pReq )
             }
             else if ( ret >= 1 )
             {
-                if (s_req_processed && s_worker_status 
+                if (s_req_processed && s_worker_status
                     && s_worker_status->m_iKillSent)
                     return -1;
                 if ( fd == pReq->m_fdListen )
@@ -3630,16 +3671,17 @@ int LSAPI_Prefork_Accept_r( LSAPI_Request * pReq )
                     if ( pReq->m_fd != -1 )
                     {
                         if (s_worker_status)
-                            __sync_lock_test_and_set(&s_worker_status->m_state,
-                                                     LSAPI_STATE_CONNECTED);
+                            __atomic_store_n(&s_worker_status->m_state,
+                                             LSAPI_STATE_CONNECTED,
+                                             __ATOMIC_SEQ_CST);
                         if (s_busy_workers)
-                            __sync_fetch_and_add(s_busy_workers, 1);
+                            __atomic_fetch_add(s_busy_workers, 1, __ATOMIC_SEQ_CST);
 
                         fd = pReq->m_fd;
-                        
+
                         lsapi_set_nblock( fd, 0 );
                         //init_conn_key( pReq->m_fd );
-                        if (!s_keepListener)
+                        if (!s_keep_listener)
                         {
                             close( pReq->m_fdListen );
                             pReq->m_fdListen = -1;
@@ -3668,7 +3710,7 @@ int LSAPI_Prefork_Accept_r( LSAPI_Request * pReq )
                 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_tmReqBegin =
                 s_worker_status->m_tmLastCheckPoint = time(NULL);
             }
             ++s_req_processed;
@@ -3742,7 +3784,7 @@ void LSAPI_No_Check_ppid(void)
 }
 
 
-int LSAPI_Get_ppid() 
+int LSAPI_Get_ppid(void)
 {
     return(s_ppid);
 }
@@ -3852,7 +3894,7 @@ static int lsapi_check_path(const char *p, char *final, int max_len)
         return -1;
     }
     p = final;
-    if (realpath(p, resolved_path) == NULL 
+    if (realpath(p, resolved_path) == NULL
         && errno != ENOENT && errno != EACCES)
         return -1;
     if (strncmp(resolved_path, "/etc/", 5) == 0)
@@ -3908,7 +3950,7 @@ int LSAPI_Init_Env_Parameters( fn_select_t fp )
     char ch;
     int n;
     int avoidFork = 0;
-    
+
     p = getenv("LSAPI_STDERR_LOG");
     if (p)
     {
@@ -3931,7 +3973,7 @@ int LSAPI_Init_Env_Parameters( fn_select_t fp )
     if ( p )
     {
         n = atoi( p );
-        s_keepListener = n;
+        s_keep_listener = n;
     }
 
     p = getenv( "LSAPI_AVOID_FORK" );
@@ -3940,7 +3982,7 @@ int LSAPI_Init_Env_Parameters( fn_select_t fp )
         avoidFork = atoi( p );
         if (avoidFork)
         {
-            s_keepListener = 2;
+            s_keep_listener = 2;
             ch = *(p + strlen(p) - 1);
             if (  ch == 'G' || ch == 'g' )
                 avoidFork *= 1024 * 1024 * 1024;
@@ -4019,7 +4061,7 @@ int LSAPI_Init_Env_Parameters( fn_select_t fp )
         {
             LSAPI_No_Check_ppid();
         }
-        
+
         p = getenv("LSAPI_MAX_BUSY_WORKER");
         if (p)
         {
@@ -4028,7 +4070,7 @@ int LSAPI_Init_Env_Parameters( fn_select_t fp )
             if (n >= 0)
                 LSAPI_No_Check_ppid();
         }
-            
+
 
         p = getenv( "LSAPI_DUMP_DEBUG_INFO" );
         if ( p )
@@ -4148,7 +4190,7 @@ void lsapi_MD5Update(struct lsapi_MD5Context *ctx, unsigned char const *buf, uns
 
 
 /*
- * Final wrapup - pad to 64-byte boundary with the bit pattern
+ * Final wrap-up - pad to 64-byte boundary with the bit pattern
  * 1 0* (64-bit count of bits processed, MSB-first)
  */
 void lsapi_MD5Final(unsigned char digest[16], struct lsapi_MD5Context *ctx)
@@ -4294,7 +4336,7 @@ static void lsapi_MD5Transform(uint32 buf[4], uint32 const in[16])
 }
 
 
-int LSAPI_Set_Restored_Parent_Pid(int pid) 
+int LSAPI_Set_Restored_Parent_Pid(int pid)
 {
     int old_ppid = s_ppid;
     s_restored_ppid = pid;
@@ -4304,7 +4346,7 @@ int LSAPI_Set_Restored_Parent_Pid(int pid)
 
 int LSAPI_Inc_Req_Processed(int cnt)
 {
-    return __sync_add_and_fetch(s_global_counter, cnt);
+    return __atomic_add_fetch(s_global_counter, cnt, __ATOMIC_SEQ_CST);
 }
 
 

data/ext/lsapi/lsruby.c

@@ -1,10 +1,11 @@
 
 #include "ruby.h"
 
-#if defined( RUBY_19 ) || defined( RUBY_2 )
-#include <ruby/util.h>
-#else
+#if defined( RUBY_VERSION_CODE ) && RUBY_VERSION_CODE < 180
 #include "util.h"
+#else
+#include <ruby/util.h>
+#include <ruby/version.h>
 #endif
 
 #include "lsapilib.h"
@@ -18,20 +19,24 @@
 #include <sys/mman.h>
 #include <fcntl.h>
 
+
+#ifndef RUBY_API_VERSION_CODE
+#define RUBY_API_VERSION_CODE (RUBY_API_VERSION_MAJOR*10000+RUBY_API_VERSION_MINOR*100+RUBY_API_VERSION_TEENY)
+#endif
+
 /* RUBY_EXTERN VALUE ruby_errinfo; */
 RUBY_EXTERN VALUE rb_stdin;
 RUBY_EXTERN VALUE rb_stdout;
-#if RUBY_VERSION_CODE < 180
+#if defined( RUBY_VERSION_CODE ) && RUBY_VERSION_CODE < 180
 RUBY_EXTERN VALUE rb_defout;
 #endif
 
 static VALUE orig_stdin;
 static VALUE orig_stdout;
 static VALUE orig_stderr;
-#if RUBY_VERSION_CODE < 180
+#if defined( RUBY_VERSION_CODE ) && RUBY_VERSION_CODE < 180
 static VALUE orig_defout;
 #endif
-
 static VALUE orig_env;
 
 static VALUE env_copy;
@@ -249,11 +254,13 @@ static VALUE lsapi_s_postfork_parent(VALUE self)
 
 static VALUE lsapi_eval_string_wrap(VALUE self, VALUE str)
 {
+#if RUBY_API_VERSION_CODE < 20700
     if (rb_safe_level() >= 4)
     {
         Check_Type(str, T_STRING);
     }
     else
+#endif
     {
         SafeStringValue(str);
     }
@@ -449,10 +456,12 @@ static VALUE lsapi_getc( VALUE self )
      *    lsapi_data *data;
      *    Data_Get_Struct(self,lsapi_data, data);
      */
+#if RUBY_API_VERSION_CODE < 20700
     if (rb_safe_level() >= 4 && !OBJ_TAINTED(self))
     {
         rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
     }
+#endif
     ch = LSAPI_ReqBodyGetChar_r( &g_req );
     if ( ch == EOF )
         return Qnil;
@@ -574,11 +583,12 @@ static VALUE lsapi_gets( VALUE self )
     int n;
     char *p = NULL;
     
+#if RUBY_API_VERSION_CODE < 20700
     if (rb_safe_level() >= 4 && !OBJ_TAINTED(self))
     {
         rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
     }
-    
+#endif
     if (createBodyBuf() == 1)
     {
         return Qnil;
@@ -600,7 +610,9 @@ static VALUE lsapi_gets( VALUE self )
         n = s_body.bodyCurrentLen - s_body.curPos;
     
     str = rb_str_buf_new( n );
+#if RUBY_API_VERSION_CODE < 20700
     OBJ_TAINT(str);
+#endif
     
     if (n > 0)
     {
@@ -618,11 +630,12 @@ static VALUE lsapi_read(int argc, VALUE *argv, VALUE self)
     int needRead;
     int nRead;
     
+#if RUBY_API_VERSION_CODE < 20700
     if (rb_safe_level() >= 4 && !OBJ_TAINTED(self))
     {
         rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
     }
-    
+#endif
     if (createBodyBuf() == 1)
     {
         return Qnil;
@@ -646,7 +659,9 @@ static VALUE lsapi_read(int argc, VALUE *argv, VALUE self)
         needRead = 0;
     
     str = rb_str_buf_new( n );
+#if RUBY_API_VERSION_CODE < 20700
     OBJ_TAINT(str);
+#endif
     if (n == 0)
         return str;
     
@@ -678,7 +693,7 @@ static VALUE lsapi_rewind(VALUE self)
     return self;
 }
 
-static VALUE lsapi_each(int argc, VALUE *argv, VALUE self)
+static VALUE lsapi_each(VALUE self)
 {
     VALUE str;
     lsapi_rewind(self);
@@ -694,15 +709,6 @@ static VALUE lsapi_each(int argc, VALUE *argv, VALUE self)
 
 static VALUE lsapi_eof(VALUE self)
 {
-    /*
-     *   lsapi_data *data;
-     * 
-     *   if (rb_safe_level() >= 4 && !OBJ_TAINTED(self))
-     *   {
-     *       rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
-}
-Data_Get_Struct(self, lsapi_data, data);
-        */
     return (LSAPI_GetReqBodyRemain_r( &g_req ) <= 0) ? Qtrue : Qfalse;
 }
 
@@ -839,7 +845,7 @@ void Init_lsapi()
     orig_stdin = rb_stdin;
     orig_stdout = rb_stdout;
     orig_stderr = rb_stderr;
-#if RUBY_VERSION_CODE < 180
+#if defined( RUBY_VERSION_CODE ) && RUBY_VERSION_CODE < 180
     orig_defout = rb_defout;
 #endif
     orig_env = rb_const_get( rb_cObject, rb_intern("ENV") );
@@ -899,9 +905,10 @@ void Init_lsapi()
     s_req_data->fn_write = LSAPI_Write_r;
     rb_stdin = rb_stdout = s_req;
     
-#if RUBY_VERSION_CODE < 180
+#if defined( RUBY_VERSION_CODE ) && RUBY_VERSION_CODE < 180
     rb_defout = s_req;
 #endif
+
     rb_global_variable(&s_req );
     
     s_req_stderr = Data_Make_Struct( cLSAPI, lsapi_data, lsapi_mark, free, s_stderr_data );

data/lsapi.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name = %q{ruby-lsapi}
-  s.version = "5.2"
-  s.date = %q{2021-01-30}
+  s.version = "5.4"
+  s.date = %q{2022-01-17}
   s.description = "This is a ruby extension for fast communication with LiteSpeed Web Server."
   s.summary = %q{A ruby extension for fast communication with LiteSpeed Web Server.}
   s.has_rdoc = false

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsapi
 version: !ruby/object:Gem::Version
-  version: '5.2'
+  version: '5.4'
 platform: ruby
 authors:
 - LiteSpeed Technologies Inc.
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-30 00:00:00.000000000 Z
+date: 2022-01-17 00:00:00.000000000 Z
 dependencies: []
 description: This is a ruby extension for fast communication with LiteSpeed Web Server.
 email: info@litespeedtech.com
@@ -33,7 +33,7 @@ files:
 homepage: http://www.litespeedtech.com/
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -48,9 +48,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: ruby-lsapi
-rubygems_version: 2.7.6.2
-signing_key: 
+rubygems_version: 3.3.3
+signing_key:
 specification_version: 4
 summary: A ruby extension for fast communication with LiteSpeed Web Server.
 test_files: []