@push.rocks/smartproxy 19.5.5 → 19.5.7

package/ts/proxies/smart-proxy/connection-manager.ts

@@ -4,6 +4,7 @@ import { SecurityManager } from './security-manager.js';
 import { TimeoutManager } from './timeout-manager.js';
 import { logger } from '../../core/utils/logger.js';
 import { LifecycleComponent } from '../../core/utils/lifecycle-component.js';
+import { cleanupSocket } from '../../core/utils/socket-utils.js';
 
 /**
  * Manages connection lifecycle, tracking, and cleanup with performance optimizations
@@ -278,10 +279,10 @@ export class ConnectionManager extends LifecycleComponent {
       }
 
       // Handle socket cleanup without delay
-      this.cleanupSocketImmediate(record, 'incoming', record.incoming);
+      cleanupSocket(record.incoming, `${record.id}-incoming`);
       
       if (record.outgoing) {
-        this.cleanupSocketImmediate(record, 'outgoing', record.outgoing);
+        cleanupSocket(record.outgoing, `${record.id}-outgoing`);
       }
 
       // Clear pendingData to avoid memory leaks
@@ -313,23 +314,6 @@ export class ConnectionManager extends LifecycleComponent {
     }
   }
   
-  /**
-   * Helper method to clean up a socket immediately
-   */
-  private cleanupSocketImmediate(record: IConnectionRecord, side: 'incoming' | 'outgoing', socket: plugins.net.Socket): void {
-    try {
-      if (!socket.destroyed) {
-        socket.destroy();
-      }
-    } catch (err) {
-      logger.log('error', `Error destroying ${side} socket: ${err}`, { 
-        connectionId: record.id, 
-        side, 
-        error: err, 
-        component: 'connection-manager' 
-      });
-    }
-  }
   
   /**
    * Creates a generic error handler for incoming or outgoing sockets
@@ -552,19 +536,13 @@ export class ConnectionManager extends LifecycleComponent {
             record.cleanupTimer = undefined;
           }
 
-          // Immediate destruction
+          // Immediate destruction using socket-utils
           if (record.incoming) {
-            record.incoming.removeAllListeners();
-            if (!record.incoming.destroyed) {
-              record.incoming.destroy();
-            }
+            cleanupSocket(record.incoming, `${record.id}-incoming-shutdown`);
           }
 
           if (record.outgoing) {
-            record.outgoing.removeAllListeners();
-            if (!record.outgoing.destroyed) {
-              record.outgoing.destroy();
-            }
+            cleanupSocket(record.outgoing, `${record.id}-outgoing-shutdown`);
           }
         } catch (err) {
           logger.log('error', `Error during connection cleanup: ${err}`, { 

package/ts/proxies/smart-proxy/http-proxy-bridge.ts

@@ -128,10 +128,24 @@ export class HttpProxyBridge {
     proxySocket.pipe(socket);
     
     // Handle cleanup
+    let cleanedUp = false;
     const cleanup = (reason: string) => {
+      if (cleanedUp) return;
+      cleanedUp = true;
+      
+      // Remove all event listeners to prevent memory leaks
+      socket.removeAllListeners('end');
+      socket.removeAllListeners('error');
+      proxySocket.removeAllListeners('end');
+      proxySocket.removeAllListeners('error');
+      
       socket.unpipe(proxySocket);
       proxySocket.unpipe(socket);
-      proxySocket.destroy();
+      
+      if (!proxySocket.destroyed) {
+        proxySocket.destroy();
+      }
+      
       cleanupCallback(reason);
     };
     

package/ts/proxies/smart-proxy/port-manager.ts

@@ -2,6 +2,7 @@ import * as plugins from '../../plugins.js';
 import type { ISmartProxyOptions } from './models/interfaces.js';
 import { RouteConnectionHandler } from './route-connection-handler.js';
 import { logger } from '../../core/utils/logger.js';
+import { cleanupSocket } from '../../core/utils/socket-utils.js';
 
 /**
  * PortManager handles the dynamic creation and removal of port listeners
@@ -64,8 +65,7 @@ export class PortManager {
     const server = plugins.net.createServer((socket) => {
       // Check if shutting down
       if (this.isShuttingDown) {
-        socket.end();
-        socket.destroy();
+        cleanupSocket(socket, 'port-manager-shutdown');
         return;
       }
       

package/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 type { ForwardingHandler } from '../../forwarding/handlers/base-handler.js';
+import { cleanupSocket } from '../../core/utils/socket-utils.js';
 
 /**
  * Handles new connection processing and setup logic with support for route-based configuration
@@ -84,8 +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' });
-      socket.end();
-      socket.destroy();
+      cleanupSocket(socket, `rejected-${ipValidation.reason}`);
       return;
     }
 
@@ -822,6 +821,38 @@ export class RouteConnectionHandler {
       return;
     }
     
+    // Track event listeners added by the handler so we can clean them up
+    const originalOn = socket.on.bind(socket);
+    const originalOnce = socket.once.bind(socket);
+    const trackedListeners: Array<{event: string; listener: (...args: any[]) => void}> = [];
+    
+    // Override socket.on to track listeners
+    socket.on = function(event: string, listener: (...args: any[]) => void) {
+      trackedListeners.push({event, listener});
+      return originalOn(event, listener);
+    } as any;
+    
+    // Override socket.once to track listeners
+    socket.once = function(event: string, listener: (...args: any[]) => void) {
+      trackedListeners.push({event, listener});
+      return originalOnce(event, listener);
+    } as any;
+    
+    // Set up automatic cleanup when socket closes
+    const cleanupHandler = () => {
+      // Remove all tracked listeners
+      for (const {event, listener} of trackedListeners) {
+        socket.removeListener(event, listener);
+      }
+      // Restore original methods
+      socket.on = originalOn;
+      socket.once = originalOnce;
+    };
+    
+    // Listen for socket close to trigger cleanup
+    originalOnce('close', cleanupHandler);
+    originalOnce('error', cleanupHandler);
+    
     // Create route context for the handler
     const routeContext = this.createRouteContext({
       connectionId: record.id,
@@ -855,6 +886,8 @@ export class RouteConnectionHandler {
               error: error.message,
               component: 'route-handler'
             });
+            // Remove all event listeners before destroying to prevent memory leaks
+            socket.removeAllListeners();
             if (!socket.destroyed) {
               socket.destroy();
             }
@@ -875,6 +908,8 @@ export class RouteConnectionHandler {
         error: error.message,
         component: 'route-handler'
       });
+      // Remove all event listeners before destroying to prevent memory leaks
+      socket.removeAllListeners();
       if (!socket.destroyed) {
         socket.destroy();
       }
@@ -1229,7 +1264,7 @@ export class RouteConnectionHandler {
           connectionId,
           serverName,
           connInfo,
-          (connectionId, reason) => this.connectionManager.initiateCleanupOnce(record, reason)
+          (_connectionId, reason) => this.connectionManager.initiateCleanupOnce(record, reason)
         );
 
         // Store the handler in the connection record so we can remove it during cleanup