3.16.4

changelog.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## 2025-02-27 - 3.16.4 - fix(PortProxy)
+Fix and enhance port proxy handling
+
+- Ensure that all created proxy servers are correctly checked for listening state.
+- Corrected the handling of ports and domain configurations within port proxy setups.
+- Expanded test coverage for handling multiple concurrent and chained proxy connections.
+
+## 2025-02-27 - 3.16.3 - fix(PortProxy)
+Refactored PortProxy to support multiple listening ports and improved modularity.
+
+- Updated PortProxy to allow multiple listening ports with flexible configuration.
+- Moved helper functions for IP and port range checks outside the class for cleaner code structure.
+
+## 2025-02-27 - 3.16.2 - fix(PortProxy)
+Fix port-based routing logic in PortProxy
+
+- Optimized the handling and checking of local ports in the global port range.
+- Fixed the logic for rejecting or accepting connections based on predefined port ranges.
+- Improved handling of the default and specific domain configurations during port-based connections.
+
+## 2025-02-27 - 3.16.1 - fix(core)
+Updated minor version numbers in dependencies for patch release.
+
+- No specific file changes detected.
+- Dependencies versioning adjusted for stability.
+
 ## 2025-02-27 - 3.16.0 - feat(PortProxy)
 Enhancements made to PortProxy settings and capabilities
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartproxy",
-  "version": "3.16.0",
+  "version": "3.16.4",
   "private": false,
   "description": "A robust and versatile proxy package designed to handle high workloads, offering features like SSL redirection, port proxying, WebSocket support, and customizable routing and authentication.",
   "main": "dist_ts/index.js",

test/test.portproxy.ts

@@ -16,12 +16,10 @@ function createTestServer(port: number): Promise<net.Server> {
         // Echo the received data back
         socket.write(`Echo: ${data.toString()}`);
       });
-
       socket.on('error', (error) => {
         console.error('[Test Server] Socket error:', error);
       });
     });
-
     server.listen(port, () => {
       console.log(`[Test Server] Listening on port ${port}`);
       resolve(server);
@@ -39,16 +37,13 @@ function createTestClient(port: number, data: string): Promise<string> {
       console.log('[Test Client] Connected to server');
       client.write(data);
     });
-
     client.on('data', (chunk) => {
       response += chunk.toString();
       client.end();
     });
-
     client.on('end', () => {
       resolve(response);
     });
-
     client.on('error', (error) => {
       reject(error);
     });
@@ -61,16 +56,18 @@ tap.test('setup port proxy test environment', async () => {
   portProxy = new PortProxy({
     fromPort: PROXY_PORT,
     toPort: TEST_SERVER_PORT,
-    toHost: 'localhost',
+    targetIP: 'localhost',
     domains: [],
     sniEnabled: false,
-    defaultAllowedIPs: ['127.0.0.1']
+    defaultAllowedIPs: ['127.0.0.1'],
+    globalPortRanges: []
   });
 });
 
 tap.test('should start port proxy', async () => {
   await portProxy.start();
-  expect(portProxy.netServer.listening).toBeTrue();
+  // Since netServers is private, we cast to any to verify that all created servers are listening.
+  expect((portProxy as any).netServers.every((server: net.Server) => server.listening)).toBeTrue();
 });
 
 tap.test('should forward TCP connections and data to localhost', async () => {
@@ -79,14 +76,15 @@ tap.test('should forward TCP connections and data to localhost', async () => {
 });
 
 tap.test('should forward TCP connections to custom host', async () => {
-  // Create a new proxy instance with a custom host
+  // Create a new proxy instance with a custom host (targetIP)
   const customHostProxy = new PortProxy({
     fromPort: PROXY_PORT + 1,
     toPort: TEST_SERVER_PORT,
-    toHost: '127.0.0.1',
+    targetIP: '127.0.0.1',
     domains: [],
     sniEnabled: false,
-    defaultAllowedIPs: ['127.0.0.1']
+    defaultAllowedIPs: ['127.0.0.1'],
+    globalPortRanges: []
   });
   
   await customHostProxy.start();
@@ -103,8 +101,8 @@ tap.test('should forward connections based on domain-specific target IP', async
   // Create a proxy with domain-specific target IPs
   const domainProxy = new PortProxy({
     fromPort: PROXY_PORT + 2,
-    toPort: TEST_SERVER_PORT,  // default port
-    toHost: 'localhost',       // default host
+    toPort: TEST_SERVER_PORT,  // default port (for non-port-range handling)
+    targetIP: 'localhost',     // default target IP
     domains: [{
       domain: 'domain1.test',
       allowedIPs: ['127.0.0.1'],
@@ -114,24 +112,26 @@ tap.test('should forward connections based on domain-specific target IP', async
       allowedIPs: ['127.0.0.1'],
       targetIP: 'localhost'
     }],
-    sniEnabled: false, // We'll test without SNI first since this is a TCP proxy test
-    defaultAllowedIPs: ['127.0.0.1']
+    sniEnabled: false,
+    defaultAllowedIPs: ['127.0.0.1'],
+    globalPortRanges: []
   });
 
   await domainProxy.start();
 
-  // Test default connection (should use default host)
+  // Test default connection (should use default targetIP)
   const response1 = await createTestClient(PROXY_PORT + 2, TEST_DATA);
   expect(response1).toEqual(`Echo: ${TEST_DATA}`);
 
-  // Create another proxy with different default host
+  // Create another proxy with a different default targetIP
   const domainProxy2 = new PortProxy({
     fromPort: PROXY_PORT + 3,
     toPort: TEST_SERVER_PORT,
-    toHost: '127.0.0.1',
+    targetIP: '127.0.0.1',
     domains: [],
     sniEnabled: false,
-    defaultAllowedIPs: ['127.0.0.1']
+    defaultAllowedIPs: ['127.0.0.1'],
+    globalPortRanges: []
   });
 
   await domainProxy2.start();
@@ -158,7 +158,6 @@ tap.test('should handle multiple concurrent connections', async () => {
 
 tap.test('should handle connection timeouts', async () => {
   const client = new net.Socket();
-  
   await new Promise<void>((resolve) => {
     client.connect(PROXY_PORT, 'localhost', () => {
       // Don't send any data, just wait for timeout
@@ -171,28 +170,30 @@ tap.test('should handle connection timeouts', async () => {
 
 tap.test('should stop port proxy', async () => {
   await portProxy.stop();
-  expect(portProxy.netServer.listening).toBeFalse();
+  expect((portProxy as any).netServers.every((server: net.Server) => !server.listening)).toBeTrue();
 });
 
-// Cleanup
+// Cleanup chained proxies tests
 tap.test('should support optional source IP preservation in chained proxies', async () => {
   // Test 1: Without IP preservation (default behavior)
   const firstProxyDefault = new PortProxy({
     fromPort: PROXY_PORT + 4,
     toPort: PROXY_PORT + 5,
-    toHost: 'localhost',
+    targetIP: 'localhost',
     domains: [],
     sniEnabled: false,
-    defaultAllowedIPs: ['127.0.0.1', '::ffff:127.0.0.1']
+    defaultAllowedIPs: ['127.0.0.1', '::ffff:127.0.0.1'],
+    globalPortRanges: []
   });
 
   const secondProxyDefault = new PortProxy({
     fromPort: PROXY_PORT + 5,
     toPort: TEST_SERVER_PORT,
-    toHost: 'localhost',
+    targetIP: 'localhost',
     domains: [],
     sniEnabled: false,
-    defaultAllowedIPs: ['127.0.0.1', '::ffff:127.0.0.1']
+    defaultAllowedIPs: ['127.0.0.1', '::ffff:127.0.0.1'],
+    globalPortRanges: []
   });
 
   await secondProxyDefault.start();
@@ -209,21 +210,23 @@ tap.test('should support optional source IP preservation in chained proxies', as
   const firstProxyPreserved = new PortProxy({
     fromPort: PROXY_PORT + 6,
     toPort: PROXY_PORT + 7,
-    toHost: 'localhost',
+    targetIP: 'localhost',
     domains: [],
     sniEnabled: false,
     defaultAllowedIPs: ['127.0.0.1'],
-    preserveSourceIP: true
+    preserveSourceIP: true,
+    globalPortRanges: []
   });
 
   const secondProxyPreserved = new PortProxy({
     fromPort: PROXY_PORT + 7,
     toPort: TEST_SERVER_PORT,
-    toHost: 'localhost',
+    targetIP: 'localhost',
     domains: [],
     sniEnabled: false,
     defaultAllowedIPs: ['127.0.0.1'],
-    preserveSourceIP: true
+    preserveSourceIP: true,
+    globalPortRanges: []
   });
 
   await secondProxyPreserved.start();
@@ -245,9 +248,10 @@ process.on('exit', () => {
   if (testServer) {
     testServer.close();
   }
-  if (portProxy && portProxy.netServer) {
+  // Use a cast to access the private property for cleanup.
+  if (portProxy && (portProxy as any).netServers) {
     portProxy.stop();
   }
 });
 
-export default tap.start();
+export default tap.start();

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartproxy',
-  version: '3.16.0',
+  version: '3.16.4',
   description: 'A robust and versatile proxy package designed to handle high workloads, offering features like SSL redirection, port proxying, WebSocket support, and customizable routing and authentication.'
 }

ts/classes.portproxy.ts

@@ -95,7 +95,7 @@ interface IConnectionRecord {
 }
 
 export class PortProxy {
-  netServer: plugins.net.Server;
+  private netServers: plugins.net.Server[] = [];
   settings: IPortProxySettings;
   // Unified record tracking each connection pair.
   private connectionRecords: Set<IConnectionRecord> = new Set();
@@ -122,43 +122,8 @@ export class PortProxy {
   }
 
   public async start() {
-    // Helper to forcefully destroy sockets.
-    const cleanUpSockets = (socketA: plugins.net.Socket, socketB?: plugins.net.Socket) => {
-      if (!socketA.destroyed) socketA.destroy();
-      if (socketB && !socketB.destroyed) socketB.destroy();
-    };
-
-    // Normalize an IP to include both IPv4 and IPv6 representations.
-    const normalizeIP = (ip: string): string[] => {
-      if (ip.startsWith('::ffff:')) {
-        const ipv4 = ip.slice(7);
-        return [ip, ipv4];
-      }
-      if (/^\d{1,3}(\.\d{1,3}){3}$/.test(ip)) {
-        return [ip, `::ffff:${ip}`];
-      }
-      return [ip];
-    };
-
-    // Check if a given IP matches any of the glob patterns.
-    const isAllowed = (ip: string, patterns: string[]): boolean => {
-      const normalizedIPVariants = normalizeIP(ip);
-      const expandedPatterns = patterns.flatMap(normalizeIP);
-      return normalizedIPVariants.some(ipVariant =>
-        expandedPatterns.some(pattern => plugins.minimatch(ipVariant, pattern))
-      );
-    };
-
-    // Check if a port falls within any of the given port ranges.
-    const isPortInRanges = (port: number, ranges: Array<{ from: number; to: number }>): boolean => {
-      return ranges.some(range => port >= range.from && port <= range.to);
-    };
-
-    // Find a matching domain config based on SNI (fallback when port ranges aren’t used)
-    const findMatchingDomain = (serverName: string): IDomainConfig | undefined =>
-      this.settings.domains.find(config => plugins.minimatch(serverName, config.domain));
-
-    this.netServer = plugins.net.createServer((socket: plugins.net.Socket) => {
+    // Define a unified connection handler for all listening ports.
+    const connectionHandler = (socket: plugins.net.Socket) => {
       const remoteIP = socket.remoteAddress || '';
       const localPort = socket.localPort; // The port on which this connection was accepted.
       const connectionRecord: IConnectionRecord = {
@@ -181,7 +146,8 @@ export class PortProxy {
           if (connectionRecord.cleanupTimer) {
             clearTimeout(connectionRecord.cleanupTimer);
           }
-          cleanUpSockets(connectionRecord.incoming, connectionRecord.outgoing || undefined);
+          if (!socket.destroyed) socket.destroy();
+          if (connectionRecord.outgoing && !connectionRecord.outgoing.destroyed) connectionRecord.outgoing.destroy();
           this.connectionRecords.delete(connectionRecord);
           console.log(`Connection from ${remoteIP} terminated. Active connections: ${this.connectionRecords.size}`);
         }
@@ -241,10 +207,11 @@ export class PortProxy {
        * @param serverName - The SNI hostname (unused when forcedDomain is provided).
        * @param initialChunk - Optional initial data chunk.
        * @param forcedDomain - If provided, overrides SNI/domain lookup (used for port-based routing).
+       * @param overridePort - If provided, use this port for the outgoing connection (typically the same as the incoming port).
        */
-      const setupConnection = (serverName: string, initialChunk?: Buffer, forcedDomain?: IDomainConfig) => {
+      const setupConnection = (serverName: string, initialChunk?: Buffer, forcedDomain?: IDomainConfig, overridePort?: number) => {
         // If a forcedDomain is provided (port-based routing), use it; otherwise, use SNI-based lookup.
-        const domainConfig = forcedDomain ? forcedDomain : (serverName ? findMatchingDomain(serverName) : undefined);
+        const domainConfig = forcedDomain ? forcedDomain : (serverName ? this.settings.domains.find(config => plugins.minimatch(serverName, config.domain)) : undefined);
         const defaultAllowed = this.settings.defaultAllowedIPs && isAllowed(remoteIP, this.settings.defaultAllowedIPs);
 
         if (!defaultAllowed && serverName && !forcedDomain) {
@@ -260,7 +227,7 @@ export class PortProxy {
         const targetHost = domainConfig?.targetIP || this.settings.targetIP!;
         const connectionOptions: plugins.net.NetConnectOpts = {
           host: targetHost,
-          port: this.settings.toPort,
+          port: overridePort !== undefined ? overridePort : this.settings.toPort,
         };
         if (this.settings.preserveSourceIP) {
           connectionOptions.localAddress = remoteIP.replace('::ffff:', '');
@@ -271,7 +238,7 @@ export class PortProxy {
         connectionRecord.outgoingStartTime = Date.now();
 
         console.log(
-          `Connection established: ${remoteIP} -> ${targetHost}:${this.settings.toPort}` +
+          `Connection established: ${remoteIP} -> ${targetHost}:${connectionOptions.port}` +
           `${serverName ? ` (SNI: ${serverName})` : forcedDomain ? ` (Port-based for domain: ${forcedDomain.domain})` : ''}`
         );
 
@@ -344,15 +311,10 @@ export class PortProxy {
       };
 
       // --- PORT RANGE-BASED HANDLING ---
-      // If global port ranges are defined, enforce port-based routing and ignore SNI.
+      // If the local port is one of the globally listened ports, we may have port-based rules.
       if (this.settings.globalPortRanges && this.settings.globalPortRanges.length > 0) {
-        if (!isPortInRanges(localPort, this.settings.globalPortRanges)) {
-          console.log(`Connection from ${remoteIP} rejected: port ${localPort} is not in global allowed ranges.`);
-          socket.destroy();
-          return;
-        }
+        // If forwardAllGlobalRanges is enabled, always forward using the global targetIP.
         if (this.settings.forwardAllGlobalRanges) {
-          // Forward connection to the global targetIP regardless of domain config.
           if (this.settings.defaultAllowedIPs && !isAllowed(remoteIP, this.settings.defaultAllowedIPs)) {
             console.log(`Connection from ${remoteIP} rejected: IP ${remoteIP} not allowed in global default allowed list.`);
             socket.end();
@@ -364,33 +326,29 @@ export class PortProxy {
             allowedIPs: this.settings.defaultAllowedIPs || [],
             targetIP: this.settings.targetIP,
             portRanges: []
-          });
+          }, localPort);
           return;
         } else {
-          // Find a matching domain config based on the incoming local port.
+          // Attempt to find a matching forced domain config based on the local port.
           const forcedDomain = this.settings.domains.find(
             domain => domain.portRanges && domain.portRanges.length > 0 && isPortInRanges(localPort, domain.portRanges)
           );
-          if (!forcedDomain) {
-            console.log(`Connection from ${remoteIP} rejected: port ${localPort} not configured in any domain's portRanges.`);
-            socket.destroy();
+          if (forcedDomain) {
+            const defaultAllowed = this.settings.defaultAllowedIPs && isAllowed(remoteIP, this.settings.defaultAllowedIPs);
+            if (!defaultAllowed && !isAllowed(remoteIP, forcedDomain.allowedIPs)) {
+              console.log(`Connection from ${remoteIP} rejected: IP not allowed for domain ${forcedDomain.domain} on port ${localPort}.`);
+              socket.end();
+              return;
+            }
+            console.log(`Port-based connection from ${remoteIP} on port ${localPort} matched domain ${forcedDomain.domain}.`);
+            setupConnection('', undefined, forcedDomain, localPort);
             return;
           }
-          // Check allowed IPs for the forced domain.
-          const defaultAllowed = this.settings.defaultAllowedIPs && isAllowed(remoteIP, this.settings.defaultAllowedIPs);
-          if (!defaultAllowed && !isAllowed(remoteIP, forcedDomain.allowedIPs)) {
-            console.log(`Connection from ${remoteIP} rejected: IP not allowed for domain ${forcedDomain.domain} on port ${localPort}.`);
-            socket.end();
-            return;
-          }
-          console.log(`Port-based connection from ${remoteIP} on port ${localPort} matched domain ${forcedDomain.domain}.`);
-          // Proceed immediately using the forced domain; ignore SNI.
-          setupConnection('', undefined, forcedDomain);
-          return;
+          // Fall through to SNI/default handling if no forced domain config is found.
         }
       }
 
-      // --- FALLBACK: SNI-BASED HANDLING (if no global port ranges are defined) ---
+      // --- FALLBACK: SNI-BASED HANDLING (or default when SNI is disabled) ---
       if (this.settings.sniEnabled) {
         socket.setTimeout(5000, () => {
           console.log(`Initial data timeout for ${remoteIP}`);
@@ -412,16 +370,36 @@ export class PortProxy {
         }
         setupConnection('');
       }
-    })
-      .on('error', (err: Error) => {
-        console.log(`Server Error: ${err.message}`);
-      })
-      .listen(this.settings.fromPort, () => {
-        console.log(
-          `PortProxy -> OK: Now listening on port ${this.settings.fromPort}` +
-          `${this.settings.sniEnabled ? ' (SNI passthrough enabled)' : ''}`
-        );
+    };
+
+    // --- SETUP LISTENERS ---
+    // Determine which ports to listen on.
+    const listeningPorts = new Set<number>();
+    if (this.settings.globalPortRanges && this.settings.globalPortRanges.length > 0) {
+      // Listen on every port defined by the global ranges.
+      for (const range of this.settings.globalPortRanges) {
+        for (let port = range.from; port <= range.to; port++) {
+          listeningPorts.add(port);
+        }
+      }
+      // Also ensure the default fromPort is listened to if it isn’t already in the ranges.
+      listeningPorts.add(this.settings.fromPort);
+    } else {
+      listeningPorts.add(this.settings.fromPort);
+    }
+
+    // Create a server for each port.
+    for (const port of listeningPorts) {
+      const server = plugins.net
+        .createServer(connectionHandler)
+        .on('error', (err: Error) => {
+          console.log(`Server Error on port ${port}: ${err.message}`);
+        });
+      server.listen(port, () => {
+        console.log(`PortProxy -> OK: Now listening on port ${port}${this.settings.sniEnabled ? ' (SNI passthrough enabled)' : ''}`);
       });
+      this.netServers.push(server);
+    }
 
     // Log active connection count and longest running durations every 10 seconds.
     this.connectionLogger = setInterval(() => {
@@ -444,14 +422,41 @@ export class PortProxy {
   }
 
   public async stop() {
-    const done = plugins.smartpromise.defer();
-    this.netServer.close(() => {
-      done.resolve();
-    });
+    // Close all servers.
+    const closePromises: Promise<void>[] = this.netServers.map(
+      server =>
+        new Promise<void>((resolve) => {
+          server.close(() => resolve());
+        })
+    );
     if (this.connectionLogger) {
       clearInterval(this.connectionLogger);
       this.connectionLogger = null;
     }
-    await done.promise;
+    await Promise.all(closePromises);
   }
-}
+}
+
+// Helper: Check if a port falls within any of the given port ranges.
+const isPortInRanges = (port: number, ranges: Array<{ from: number; to: number }>): boolean => {
+  return ranges.some(range => port >= range.from && port <= range.to);
+};
+
+// Helper: Check if a given IP matches any of the glob patterns.
+const isAllowed = (ip: string, patterns: string[]): boolean => {
+  const normalizeIP = (ip: string): string[] => {
+    if (ip.startsWith('::ffff:')) {
+      const ipv4 = ip.slice(7);
+      return [ip, ipv4];
+    }
+    if (/^\d{1,3}(\.\d{1,3}){3}$/.test(ip)) {
+      return [ip, `::ffff:${ip}`];
+    }
+    return [ip];
+  };
+  const normalizedIPVariants = normalizeIP(ip);
+  const expandedPatterns = patterns.flatMap(normalizeIP);
+  return normalizedIPVariants.some(ipVariant =>
+    expandedPatterns.some(pattern => plugins.minimatch(ipVariant, pattern))
+  );
+};