Enhance socket cleanup and management for improved connection handling

- Refactor cleanupSocket function to support options for immediate destruction, allowing drain, and grace periods.
- Introduce createIndependentSocketHandlers for better management of half-open connections between client and server sockets.
- Update various handlers (HTTP, HTTPS passthrough, HTTPS terminate) to utilize new cleanup and socket management functions.
- Implement custom timeout handling in socket setup to prevent immediate closure during keep-alive connections.
- Add tests for long-lived connections and half-open connection scenarios to ensure stability and reliability.
- Adjust connection manager to handle socket cleanup based on activity status, improving resource management.

ts/proxies/smart-proxy/route-connection-handler.ts

@@ -9,7 +9,7 @@ import { TlsManager } from './tls-manager.js';
 import { HttpProxyBridge } from './http-proxy-bridge.js';
 import { TimeoutManager } from './timeout-manager.js';
 import { RouteManager } from './route-manager.js';
-import { cleanupSocket } from '../../core/utils/socket-utils.js';
+import { cleanupSocket, createIndependentSocketHandlers, setupSocketHandlers } from '../../core/utils/socket-utils.js';
 
 /**
  * Handles new connection processing and setup logic with support for route-based configuration
@@ -84,7 +84,7 @@ export class RouteConnectionHandler {
     const ipValidation = this.securityManager.validateIP(remoteIP);
     if (!ipValidation.allowed) {
       logger.log('warn', `Connection rejected`, { remoteIP, reason: ipValidation.reason, component: 'route-handler' });
-      cleanupSocket(socket, `rejected-${ipValidation.reason}`);
+      cleanupSocket(socket, `rejected-${ipValidation.reason}`, { immediate: true });
       return;
     }
 
@@ -1110,9 +1110,8 @@ export class RouteConnectionHandler {
     // Setup improved error handling for outgoing connection
     this.setupOutgoingErrorHandler(connectionId, targetSocket, record, socket, finalTargetHost, finalTargetPort);
 
-    // Setup close handlers
-    targetSocket.on('close', this.connectionManager.handleClose('outgoing', record));
-    socket.on('close', this.connectionManager.handleClose('incoming', record));
+    // Note: Close handlers are managed by independent socket handlers above
+    // We don't register handleClose here to avoid bilateral cleanup
     
     // Setup error handlers for incoming socket
     socket.on('error', this.connectionManager.handleError('incoming', record));
@@ -1225,14 +1224,64 @@ export class RouteConnectionHandler {
         record.pendingDataSize = 0;
       }
 
-      // Immediately setup bidirectional piping - much simpler than manual data management
-      socket.pipe(targetSocket);
-      targetSocket.pipe(socket);
+      // Set up independent socket handlers for half-open connection support
+      const { cleanupClient, cleanupServer } = createIndependentSocketHandlers(
+        socket,
+        targetSocket,
+        (reason) => {
+          this.connectionManager.initiateCleanupOnce(record, reason);
+        }
+      );
 
-      // Track incoming data for bytes counting - do this after piping is set up
+      // Setup socket handlers with custom timeout handling
+      setupSocketHandlers(socket, cleanupClient, (sock) => {
+        // Don't close on timeout for keep-alive connections
+        if (record.hasKeepAlive) {
+          sock.setTimeout(this.settings.socketTimeout || 3600000);
+        }
+      }, 'client');
+
+      setupSocketHandlers(targetSocket, cleanupServer, (sock) => {
+        // Don't close on timeout for keep-alive connections  
+        if (record.hasKeepAlive) {
+          sock.setTimeout(this.settings.socketTimeout || 3600000);
+        }
+      }, 'server');
+
+      // Forward data from client to target with backpressure handling
       socket.on('data', (chunk: Buffer) => {
         record.bytesReceived += chunk.length;
         this.timeoutManager.updateActivity(record);
+        
+        if (targetSocket.writable) {
+          const flushed = targetSocket.write(chunk);
+          
+          // Handle backpressure
+          if (!flushed) {
+            socket.pause();
+            targetSocket.once('drain', () => {
+              socket.resume();
+            });
+          }
+        }
+      });
+
+      // Forward data from target to client with backpressure handling
+      targetSocket.on('data', (chunk: Buffer) => {
+        record.bytesSent += chunk.length;
+        this.timeoutManager.updateActivity(record);
+        
+        if (socket.writable) {
+          const flushed = socket.write(chunk);
+          
+          // Handle backpressure
+          if (!flushed) {
+            targetSocket.pause();
+            socket.once('drain', () => {
+              targetSocket.resume();
+            });
+          }
+        }
       });
 
       // Log successful connection