@push.rocks/smartproxy 3.23.0 → 3.24.0

package/ts/classes.portproxy.ts

@@ -23,6 +23,13 @@ export interface IPortProxySettings extends plugins.tls.TlsOptions {
   globalPortRanges: Array<{ from: number; to: number }>; // Global allowed port ranges
   forwardAllGlobalRanges?: boolean; // When true, forwards all connections on global port ranges to the global targetIP
   gracefulShutdownTimeout?: number; // (ms) maximum time to wait for connections to close during shutdown
+  
+  // Socket optimization settings
+  noDelay?: boolean;                  // Disable Nagle's algorithm (default: true)
+  keepAlive?: boolean;                // Enable TCP keepalive (default: true)
+  keepAliveInitialDelay?: number;     // Initial delay before sending keepalive probes (ms)
+  maxPendingDataSize?: number;        // Maximum bytes to buffer during connection setup
+  initialDataTimeout?: number;        // Timeout for initial data/SNI (ms)
 }
 
 /**
@@ -99,6 +106,8 @@ interface IConnectionRecord {
   connectionClosed: boolean;        // Flag to prevent multiple cleanup attempts
   cleanupTimer?: NodeJS.Timeout;    // Timer for max lifetime/inactivity
   lastActivity: number;             // Last activity timestamp for inactivity detection
+  pendingData: Buffer[];            // Buffer to hold data during connection setup
+  pendingDataSize: number;          // Track total size of pending data
 }
 
 // Helper: Check if a port falls within any of the given port ranges
@@ -160,6 +169,11 @@ export class PortProxy {
       targetIP: settingsArg.targetIP || 'localhost',
       maxConnectionLifetime: settingsArg.maxConnectionLifetime || 600000,
       gracefulShutdownTimeout: settingsArg.gracefulShutdownTimeout || 30000,
+      noDelay: settingsArg.noDelay !== undefined ? settingsArg.noDelay : true,
+      keepAlive: settingsArg.keepAlive !== undefined ? settingsArg.keepAlive : true,
+      keepAliveInitialDelay: settingsArg.keepAliveInitialDelay || 60000, // 1 minute
+      maxPendingDataSize: settingsArg.maxPendingDataSize || 1024 * 1024, // 1MB
+      initialDataTimeout: settingsArg.initialDataTimeout || 5000 // 5 seconds
     };
   }
 
@@ -186,16 +200,29 @@ export class PortProxy {
         if (!record.incoming.destroyed) {
           // Try graceful shutdown first, then force destroy after a short timeout
           record.incoming.end();
-          setTimeout(() => {
-            if (record && !record.incoming.destroyed) {
-              record.incoming.destroy();
+          const incomingTimeout = setTimeout(() => {
+            try {
+              if (record && !record.incoming.destroyed) {
+                record.incoming.destroy();
+              }
+            } catch (err) {
+              console.log(`Error destroying incoming socket: ${err}`);
             }
           }, 1000);
+          
+          // Ensure the timeout doesn't block Node from exiting
+          if (incomingTimeout.unref) {
+            incomingTimeout.unref();
+          }
         }
       } catch (err) {
         console.log(`Error closing incoming socket: ${err}`);
-        if (!record.incoming.destroyed) {
-          record.incoming.destroy();
+        try {
+          if (!record.incoming.destroyed) {
+            record.incoming.destroy();
+          }
+        } catch (destroyErr) {
+          console.log(`Error destroying incoming socket: ${destroyErr}`);
         }
       }
       
@@ -203,19 +230,36 @@ export class PortProxy {
         if (record.outgoing && !record.outgoing.destroyed) {
           // Try graceful shutdown first, then force destroy after a short timeout
           record.outgoing.end();
-          setTimeout(() => {
-            if (record && record.outgoing && !record.outgoing.destroyed) {
-              record.outgoing.destroy();
+          const outgoingTimeout = setTimeout(() => {
+            try {
+              if (record && record.outgoing && !record.outgoing.destroyed) {
+                record.outgoing.destroy();
+              }
+            } catch (err) {
+              console.log(`Error destroying outgoing socket: ${err}`);
             }
           }, 1000);
+          
+          // Ensure the timeout doesn't block Node from exiting
+          if (outgoingTimeout.unref) {
+            outgoingTimeout.unref();
+          }
         }
       } catch (err) {
         console.log(`Error closing outgoing socket: ${err}`);
-        if (record.outgoing && !record.outgoing.destroyed) {
-          record.outgoing.destroy();
+        try {
+          if (record.outgoing && !record.outgoing.destroyed) {
+            record.outgoing.destroy();
+          }
+        } catch (destroyErr) {
+          console.log(`Error destroying outgoing socket: ${destroyErr}`);
         }
       }
       
+      // Clear pendingData to avoid memory leaks
+      record.pendingData = [];
+      record.pendingDataSize = 0;
+      
       // Remove the record from the tracking map
       this.connectionRecords.delete(record.id);
       
@@ -239,6 +283,11 @@ export class PortProxy {
   }
 
   public async start() {
+    // Don't start if already shutting down
+    if (this.isShuttingDown) {
+      console.log("Cannot start PortProxy while it's shutting down");
+      return;
+    }
     // Define a unified connection handler for all listening ports.
     const connectionHandler = (socket: plugins.net.Socket) => {
       if (this.isShuttingDown) {
@@ -250,6 +299,10 @@ export class PortProxy {
       const remoteIP = socket.remoteAddress || '';
       const localPort = socket.localPort; // The port on which this connection was accepted.
       
+      // Apply socket optimizations
+      socket.setNoDelay(this.settings.noDelay);
+      socket.setKeepAlive(this.settings.keepAlive, this.settings.keepAliveInitialDelay);
+      
       const connectionId = generateConnectionId();
       const connectionRecord: IConnectionRecord = {
         id: connectionId,
@@ -257,7 +310,9 @@ export class PortProxy {
         outgoing: null,
         incomingStartTime: Date.now(),
         lastActivity: Date.now(),
-        connectionClosed: false
+        connectionClosed: false,
+        pendingData: [], // Initialize buffer for pending data
+        pendingDataSize: 0 // Initialize buffer size counter
       };
       this.connectionRecords.set(connectionId, connectionRecord);
       
@@ -294,11 +349,15 @@ export class PortProxy {
       if (this.settings.sniEnabled) {
         initialTimeout = setTimeout(() => {
           if (!initialDataReceived) {
-            console.log(`Initial data timeout for ${remoteIP}`);
+            console.log(`Initial data timeout (${this.settings.initialDataTimeout}ms) for connection from ${remoteIP} on port ${localPort}`);
+            if (incomingTerminationReason === null) {
+              incomingTerminationReason = 'initial_timeout';
+              this.incrementTerminationStat('incoming', 'initial_timeout');
+            }
             socket.end();
             cleanupOnce();
           }
-        }, 5000);
+        }, this.settings.initialDataTimeout || 5000);
       } else {
         initialDataReceived = true;
       }
@@ -391,29 +450,83 @@ export class PortProxy {
           connectionOptions.localAddress = remoteIP.replace('::ffff:', '');
         }
 
-        // Create the target socket and immediately set up data piping
+        // Pause the incoming socket to prevent buffer overflows
+        socket.pause();
+
+        // Temporary handler to collect data during connection setup
+        const tempDataHandler = (chunk: Buffer) => {
+          // Check if adding this chunk would exceed the buffer limit
+          const newSize = connectionRecord.pendingDataSize + chunk.length;
+          
+          if (this.settings.maxPendingDataSize && newSize > this.settings.maxPendingDataSize) {
+            console.log(`Buffer limit exceeded for connection from ${remoteIP}: ${newSize} bytes > ${this.settings.maxPendingDataSize} bytes`);
+            socket.end(); // Gracefully close the socket
+            return initiateCleanupOnce('buffer_limit_exceeded');
+          }
+          
+          // Buffer the chunk and update the size counter
+          connectionRecord.pendingData.push(Buffer.from(chunk));
+          connectionRecord.pendingDataSize = newSize;
+          this.updateActivity(connectionRecord);
+        };
+
+        // Add the temp handler to capture all incoming data during connection setup
+        socket.on('data', tempDataHandler);
+
+        // Add initial chunk to pending data if present
+        if (initialChunk) {
+          connectionRecord.pendingData.push(Buffer.from(initialChunk));
+          connectionRecord.pendingDataSize = initialChunk.length;
+        }
+
+        // Create the target socket but don't set up piping immediately
         const targetSocket = plugins.net.connect(connectionOptions);
         connectionRecord.outgoing = targetSocket;
         connectionRecord.outgoingStartTime = Date.now();
         
-        // Set up the pipe immediately to ensure data flows without delay
-        if (initialChunk) {
-          socket.unshift(initialChunk);
-        }
+        // Apply socket optimizations
+        targetSocket.setNoDelay(this.settings.noDelay);
+        targetSocket.setKeepAlive(this.settings.keepAlive, this.settings.keepAliveInitialDelay);
         
-        socket.pipe(targetSocket);
-        targetSocket.pipe(socket);
+        // Setup specific error handler for connection phase
+        targetSocket.once('error', (err) => {
+          // This handler runs only once during the initial connection phase
+          const code = (err as any).code;
+          console.log(`Connection setup error to ${targetHost}:${connectionOptions.port}: ${err.message} (${code})`);
+          
+          // Resume the incoming socket to prevent it from hanging
+          socket.resume();
+          
+          if (code === 'ECONNREFUSED') {
+            console.log(`Target ${targetHost}:${connectionOptions.port} refused connection`);
+          } else if (code === 'ETIMEDOUT') {
+            console.log(`Connection to ${targetHost}:${connectionOptions.port} timed out`);
+          } else if (code === 'ECONNRESET') {
+            console.log(`Connection to ${targetHost}:${connectionOptions.port} was reset`);
+          } else if (code === 'EHOSTUNREACH') {
+            console.log(`Host ${targetHost} is unreachable`);
+          }
+          
+          // Clear any existing error handler after connection phase
+          targetSocket.removeAllListeners('error');
+          
+          // Re-add the normal error handler for established connections
+          targetSocket.on('error', handleError('outgoing'));
+          
+          if (outgoingTerminationReason === null) {
+            outgoingTerminationReason = 'connection_failed';
+            this.incrementTerminationStat('outgoing', 'connection_failed');
+          }
+          
+          // Clean up the connection
+          initiateCleanupOnce(`connection_failed_${code}`);
+        });
         
-        console.log(
-          `Connection established: ${remoteIP} -> ${targetHost}:${connectionOptions.port}` +
-          `${serverName ? ` (SNI: ${serverName})` : forcedDomain ? ` (Port-based for domain: ${forcedDomain.domains.join(', ')})` : ''}`
-        );
-
-        // Add appropriate handlers for connection management
-        socket.on('error', handleError('incoming'));
-        targetSocket.on('error', handleError('outgoing'));
-        socket.on('close', handleClose('incoming'));
+        // Setup close handler
         targetSocket.on('close', handleClose('outgoing'));
+        socket.on('close', handleClose('incoming'));
+        
+        // Handle timeouts
         socket.on('timeout', () => {
           console.log(`Timeout on incoming side from ${remoteIP}`);
           if (incomingTerminationReason === null) {
@@ -435,13 +548,81 @@ export class PortProxy {
         socket.setTimeout(120000);
         targetSocket.setTimeout(120000);
         
-        // Update activity for both sockets
-        socket.on('data', () => {
-          connectionRecord.lastActivity = Date.now();
-        });
-        
-        targetSocket.on('data', () => {
-          connectionRecord.lastActivity = Date.now();
+        // Wait for the outgoing connection to be ready before setting up piping
+        targetSocket.once('connect', () => {
+          // Clear the initial connection error handler
+          targetSocket.removeAllListeners('error');
+          
+          // Add the normal error handler for established connections
+          targetSocket.on('error', handleError('outgoing'));
+          
+          // Remove temporary data handler
+          socket.removeListener('data', tempDataHandler);
+          
+          // Flush all pending data to target
+          if (connectionRecord.pendingData.length > 0) {
+            const combinedData = Buffer.concat(connectionRecord.pendingData);
+            targetSocket.write(combinedData, (err) => {
+              if (err) {
+                console.log(`Error writing pending data to target: ${err.message}`);
+                return initiateCleanupOnce('write_error');
+              }
+              
+              // Now set up piping for future data and resume the socket
+              socket.pipe(targetSocket);
+              targetSocket.pipe(socket);
+              socket.resume(); // Resume the socket after piping is established
+              
+              console.log(
+                `Connection established: ${remoteIP} -> ${targetHost}:${connectionOptions.port}` +
+                `${serverName ? ` (SNI: ${serverName})` : forcedDomain ? ` (Port-based for domain: ${forcedDomain.domains.join(', ')})` : ''}`
+              );
+            });
+          } else {
+            // No pending data, so just set up piping
+            socket.pipe(targetSocket);
+            targetSocket.pipe(socket);
+            socket.resume(); // Resume the socket after piping is established
+            
+            console.log(
+              `Connection established: ${remoteIP} -> ${targetHost}:${connectionOptions.port}` +
+              `${serverName ? ` (SNI: ${serverName})` : forcedDomain ? ` (Port-based for domain: ${forcedDomain.domains.join(', ')})` : ''}`
+            );
+          }
+          
+          // Clear the buffer now that we've processed it
+          connectionRecord.pendingData = [];
+          connectionRecord.pendingDataSize = 0;
+          
+          // Set up activity tracking
+          socket.on('data', () => {
+            connectionRecord.lastActivity = Date.now();
+          });
+          
+          targetSocket.on('data', () => {
+            connectionRecord.lastActivity = Date.now();
+          });
+          
+          // Add the renegotiation listener (we don't need setImmediate here anymore
+          // since we're already in the connect callback)
+          if (serverName) {
+            socket.on('data', (renegChunk: Buffer) => {
+              if (renegChunk.length > 0 && renegChunk.readUInt8(0) === 22) {
+                try {
+                  // Try to extract SNI from potential renegotiation
+                  const newSNI = extractSNI(renegChunk);
+                  if (newSNI && newSNI !== connectionRecord.lockedDomain) {
+                    console.log(`Rehandshake detected with different SNI: ${newSNI} vs locked ${connectionRecord.lockedDomain}. Terminating connection.`);
+                    initiateCleanupOnce('sni_mismatch');
+                  } else if (newSNI) {
+                    console.log(`Rehandshake detected with same SNI: ${newSNI}. Allowing.`);
+                  }
+                } catch (err) {
+                  console.log(`Error processing potential renegotiation: ${err}. Allowing connection to continue.`);
+                }
+              }
+            });
+          }
         });
 
         // Initialize a cleanup timer for max connection lifetime
@@ -514,27 +695,6 @@ export class PortProxy {
           connectionRecord.lockedDomain = serverName;
           console.log(`Received connection from ${remoteIP} with SNI: ${serverName}`);
           
-          // Delay adding the renegotiation listener until the next tick,
-          // so the initial ClientHello is not reprocessed.
-          setImmediate(() => {
-            socket.on('data', (renegChunk: Buffer) => {
-              if (renegChunk.length > 0 && renegChunk.readUInt8(0) === 22) {
-                try {
-                  // Try to extract SNI from potential renegotiation
-                  const newSNI = extractSNI(renegChunk);
-                  if (newSNI && newSNI !== connectionRecord.lockedDomain) {
-                    console.log(`Rehandshake detected with different SNI: ${newSNI} vs locked ${connectionRecord.lockedDomain}. Terminating connection.`);
-                    initiateCleanupOnce('sni_mismatch');
-                  } else if (newSNI) {
-                    console.log(`Rehandshake detected with same SNI: ${newSNI}. Allowing.`);
-                  }
-                } catch (err) {
-                  console.log(`Error processing potential renegotiation: ${err}. Allowing connection to continue.`);
-                }
-              }
-            });
-          });
-          
           setupConnection(serverName, chunk);
         });
       } else {
@@ -577,6 +737,8 @@ export class PortProxy {
 
     // Log active connection count, longest running durations, and run parity checks every 10 seconds.
     this.connectionLogger = setInterval(() => {
+      // Immediately return if shutting down
+      if (this.isShuttingDown) return;
       if (this.isShuttingDown) return;
       
       const now = Date.now();
@@ -632,7 +794,16 @@ export class PortProxy {
     const closeServerPromises: Promise<void>[] = this.netServers.map(
       server =>
         new Promise<void>((resolve) => {
-          server.close(() => resolve());
+          if (!server.listening) {
+            resolve();
+            return;
+          }
+          server.close((err) => {
+            if (err) {
+              console.log(`Error closing server: ${err.message}`);
+            }
+            resolve();
+          });
         })
     );
     
@@ -646,47 +817,77 @@ export class PortProxy {
     await Promise.all(closeServerPromises);
     console.log("All servers closed. Cleaning up active connections...");
     
-    // Clean up active connections
+    // Force destroy all active connections immediately
     const connectionIds = [...this.connectionRecords.keys()];
     console.log(`Cleaning up ${connectionIds.length} active connections...`);
     
+    // First pass: End all connections gracefully
     for (const id of connectionIds) {
       const record = this.connectionRecords.get(id);
-      if (record && !record.connectionClosed) {
-        this.cleanupConnection(record, 'shutdown');
+      if (record) {
+        try {
+          // Clear any timers
+          if (record.cleanupTimer) {
+            clearTimeout(record.cleanupTimer);
+            record.cleanupTimer = undefined;
+          }
+          
+          // End sockets gracefully
+          if (record.incoming && !record.incoming.destroyed) {
+            record.incoming.end();
+          }
+          
+          if (record.outgoing && !record.outgoing.destroyed) {
+            record.outgoing.end();
+          }
+        } catch (err) {
+          console.log(`Error during graceful connection end for ${id}: ${err}`);
+        }
       }
     }
     
-    // Wait for graceful shutdown or timeout
-    const shutdownTimeout = this.settings.gracefulShutdownTimeout || 30000;
-    await new Promise<void>((resolve) => {
-      const checkInterval = setInterval(() => {
-        if (this.connectionRecords.size === 0) {
-          clearInterval(checkInterval);
-          resolve(); // lets resolve here as early as we reach 0 remaining connections
-        }
-      }, 1000);
-      
-      // Force resolve after timeout
-      setTimeout(() => {
-        clearInterval(checkInterval);
-        if (this.connectionRecords.size > 0) {
-          console.log(`Forcing shutdown with ${this.connectionRecords.size} connections still active`);
-          
-          // Force destroy any remaining connections
-          for (const record of this.connectionRecords.values()) {
+    // Short delay to allow graceful ends to process
+    await new Promise(resolve => setTimeout(resolve, 100));
+    
+    // Second pass: Force destroy everything
+    for (const id of connectionIds) {
+      const record = this.connectionRecords.get(id);
+      if (record) {
+        try {
+          // Remove all listeners to prevent memory leaks
+          if (record.incoming) {
+            record.incoming.removeAllListeners();
             if (!record.incoming.destroyed) {
               record.incoming.destroy();
             }
-            if (record.outgoing && !record.outgoing.destroyed) {
+          }
+          
+          if (record.outgoing) {
+            record.outgoing.removeAllListeners();
+            if (!record.outgoing.destroyed) {
               record.outgoing.destroy();
             }
           }
-          this.connectionRecords.clear();
+        } catch (err) {
+          console.log(`Error during forced connection destruction for ${id}: ${err}`);
         }
-        resolve();
-      }, shutdownTimeout);
-    });
+      }
+    }
+    
+    // Clear the connection records map
+    this.connectionRecords.clear();
+    
+    // Clear the domain target indices map to prevent memory leaks
+    this.domainTargetIndices.clear();
+    
+    // Clear any servers array
+    this.netServers = [];
+    
+    // Reset termination stats
+    this.terminationStats = {
+      incoming: {},
+      outgoing: {}
+    };
     
     console.log("PortProxy shutdown complete.");
   }