@push.rocks/smartproxy 15.0.2 → 16.0.3

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

@@ -1,26 +1,23 @@
 import * as plugins from '../../plugins.js';
 import type {
   IConnectionRecord,
-  IDomainConfig,
   ISmartProxyOptions
 } from './models/interfaces.js';
 import {
-  isRoutedOptions,
-  isLegacyOptions
+  isRoutedOptions
 } from './models/interfaces.js';
 import type {
   IRouteConfig,
-  IRouteAction
+  IRouteAction,
+  IRouteContext
 } from './models/route-types.js';
 import { ConnectionManager } from './connection-manager.js';
 import { SecurityManager } from './security-manager.js';
-import { DomainConfigManager } from './domain-config-manager.js';
 import { TlsManager } from './tls-manager.js';
 import { NetworkProxyBridge } from './network-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 type { TForwardingType } from '../../forwarding/config/forwarding-types.js';
 
 /**
  * Handles new connection processing and setup logic with support for route-based configuration
@@ -28,11 +25,13 @@ import type { TForwardingType } from '../../forwarding/config/forwarding-types.j
 export class RouteConnectionHandler {
   private settings: ISmartProxyOptions;
 
+  // Cache for route contexts to avoid recreation
+  private routeContextCache: Map<string, IRouteContext> = new Map();
+
   constructor(
     settings: ISmartProxyOptions,
     private connectionManager: ConnectionManager,
     private securityManager: SecurityManager,
-    private domainConfigManager: DomainConfigManager,
     private tlsManager: TlsManager,
     private networkProxyBridge: NetworkProxyBridge,
     private timeoutManager: TimeoutManager,
@@ -41,6 +40,47 @@ export class RouteConnectionHandler {
     this.settings = settings;
   }
 
+  /**
+   * Create a route context object for port and host mapping functions
+   */
+  private createRouteContext(options: {
+    connectionId: string;
+    port: number;
+    domain?: string;
+    clientIp: string;
+    serverIp: string;
+    isTls: boolean;
+    tlsVersion?: string;
+    routeName?: string;
+    routeId?: string;
+    path?: string;
+    query?: string;
+    headers?: Record<string, string>;
+  }): IRouteContext {
+    return {
+      // Connection information
+      port: options.port,
+      domain: options.domain,
+      clientIp: options.clientIp,
+      serverIp: options.serverIp,
+      path: options.path,
+      query: options.query,
+      headers: options.headers,
+
+      // TLS information
+      isTls: options.isTls,
+      tlsVersion: options.tlsVersion,
+
+      // Route information
+      routeName: options.routeName,
+      routeId: options.routeId,
+
+      // Additional properties
+      timestamp: Date.now(),
+      connectionId: options.connectionId
+    };
+  }
+
   /**
    * Handle a new incoming connection
    */
@@ -244,37 +284,20 @@ export class RouteConnectionHandler {
 
     if (!routeMatch) {
       console.log(`[${connectionId}] No route found for ${serverName || 'connection'} on port ${localPort}`);
-      
-      // Fall back to legacy matching if we're using a hybrid configuration
-      const domainConfig = serverName 
-        ? this.domainConfigManager.findDomainConfig(serverName)
-        : this.domainConfigManager.findDomainConfigForPort(localPort);
 
-      if (domainConfig) {
-        if (this.settings.enableDetailedLogging) {
-          console.log(`[${connectionId}] Using legacy domain configuration for ${serverName || 'port ' + localPort}`);
-        }
-        
-        // Associate this domain config with the connection
-        record.domainConfig = domainConfig;
-        
-        // Handle the connection using the legacy setup
-        return this.handleLegacyConnection(socket, record, serverName, domainConfig, initialChunk);
-      }
-      
-      // No matching route or domain config, use default/fallback handling
+      // No matching route, use default/fallback handling
       console.log(`[${connectionId}] Using default route handling for connection`);
-      
+
       // Check default security settings
       const defaultSecuritySettings = this.settings.defaults?.security;
       if (defaultSecuritySettings) {
-        if (defaultSecuritySettings.allowedIPs && defaultSecuritySettings.allowedIPs.length > 0) {
+        if (defaultSecuritySettings.allowedIps && defaultSecuritySettings.allowedIps.length > 0) {
           const isAllowed = this.securityManager.isIPAuthorized(
             remoteIP,
-            defaultSecuritySettings.allowedIPs,
-            defaultSecuritySettings.blockedIPs || []
+            defaultSecuritySettings.allowedIps,
+            defaultSecuritySettings.blockedIps || []
           );
-          
+
           if (!isAllowed) {
             console.log(`[${connectionId}] IP ${remoteIP} not in default allowed list`);
             socket.end();
@@ -282,34 +305,24 @@ export class RouteConnectionHandler {
             return;
           }
         }
-      } else if (this.settings.defaultAllowedIPs && this.settings.defaultAllowedIPs.length > 0) {
-        // Legacy default IP restrictions
-        const isAllowed = this.securityManager.isIPAuthorized(
-          remoteIP,
-          this.settings.defaultAllowedIPs,
-          this.settings.defaultBlockedIPs || []
-        );
-        
-        if (!isAllowed) {
-          console.log(`[${connectionId}] IP ${remoteIP} not in default allowed list`);
-          socket.end();
-          this.connectionManager.cleanupConnection(record, 'ip_blocked');
-          return;
-        }
       }
       
       // Setup direct connection with default settings
-      let targetHost: string;
-      let targetPort: number;
+      if (this.settings.defaults?.target) {
+        // Use defaults from configuration
+        const targetHost = this.settings.defaults.target.host;
+        const targetPort = this.settings.defaults.target.port;
 
-      if (isRoutedOptions(this.settings) && this.settings.defaults?.target) {
-        // Use defaults from routed configuration
-        targetHost = this.settings.defaults.target.host;
-        targetPort = this.settings.defaults.target.port;
-      } else if (this.settings.targetIP && this.settings.toPort) {
-        // Fall back to legacy settings
-        targetHost = this.settings.targetIP;
-        targetPort = this.settings.toPort;
+        return this.setupDirectConnection(
+          socket,
+          record,
+          undefined,
+          serverName,
+          initialChunk,
+          undefined,
+          targetHost,
+          targetPort
+        );
       } else {
         // No default target available, terminate the connection
         console.log(`[${connectionId}] No default target configured. Closing connection.`);
@@ -317,17 +330,6 @@ export class RouteConnectionHandler {
         this.connectionManager.cleanupConnection(record, 'no_default_target');
         return;
       }
-
-      return this.setupDirectConnection(
-        socket,
-        record,
-        undefined,
-        serverName,
-        initialChunk,
-        undefined,
-        targetHost,
-        targetPort
-      );
     }
     
     // A matching route was found
@@ -368,7 +370,7 @@ export class RouteConnectionHandler {
   ): void {
     const connectionId = record.id;
     const action = route.action;
-    
+
     // We should have a target configuration for forwarding
     if (!action.target) {
       console.log(`[${connectionId}] Forward action missing target configuration`);
@@ -376,24 +378,82 @@ export class RouteConnectionHandler {
       this.connectionManager.cleanupConnection(record, 'missing_target');
       return;
     }
-    
+
+    // Create the routing context for this connection
+    const routeContext = this.createRouteContext({
+      connectionId: record.id,
+      port: record.localPort,
+      domain: record.lockedDomain,
+      clientIp: record.remoteIP,
+      serverIp: socket.localAddress || '',
+      isTls: record.isTLS || false,
+      tlsVersion: record.tlsVersion,
+      routeName: route.name,
+      routeId: route.id
+    });
+
+    // Cache the context for potential reuse
+    this.routeContextCache.set(connectionId, routeContext);
+
+    // Determine host using function or static value
+    let targetHost: string | string[];
+    if (typeof action.target.host === 'function') {
+      try {
+        targetHost = action.target.host(routeContext);
+        if (this.settings.enableDetailedLogging) {
+          console.log(`[${connectionId}] Dynamic host resolved to: ${Array.isArray(targetHost) ? targetHost.join(', ') : targetHost}`);
+        }
+      } catch (err) {
+        console.log(`[${connectionId}] Error in host mapping function: ${err}`);
+        socket.end();
+        this.connectionManager.cleanupConnection(record, 'host_mapping_error');
+        return;
+      }
+    } else {
+      targetHost = action.target.host;
+    }
+
+    // If an array of hosts, select one randomly for load balancing
+    const selectedHost = Array.isArray(targetHost)
+      ? targetHost[Math.floor(Math.random() * targetHost.length)]
+      : targetHost;
+
+    // Determine port using function or static value
+    let targetPort: number;
+    if (typeof action.target.port === 'function') {
+      try {
+        targetPort = action.target.port(routeContext);
+        if (this.settings.enableDetailedLogging) {
+          console.log(`[${connectionId}] Dynamic port mapping: ${record.localPort} -> ${targetPort}`);
+        }
+        // Store the resolved target port in the context for potential future use
+        routeContext.targetPort = targetPort;
+      } catch (err) {
+        console.log(`[${connectionId}] Error in port mapping function: ${err}`);
+        socket.end();
+        this.connectionManager.cleanupConnection(record, 'port_mapping_error');
+        return;
+      }
+    } else if (action.target.preservePort) {
+      // Use incoming port if preservePort is true
+      targetPort = record.localPort;
+    } else {
+      // Use static port from configuration
+      targetPort = action.target.port;
+    }
+
+    // Store the resolved host in the context
+    routeContext.targetHost = selectedHost;
+
     // Determine if this needs TLS handling
     if (action.tls) {
       switch (action.tls.mode) {
         case 'passthrough':
           // For TLS passthrough, just forward directly
           if (this.settings.enableDetailedLogging) {
-            console.log(`[${connectionId}] Using TLS passthrough to ${action.target.host}`);
+            console.log(`[${connectionId}] Using TLS passthrough to ${selectedHost}:${targetPort}`);
           }
           
-          // Allow for array of hosts
-          const targetHost = Array.isArray(action.target.host) 
-            ? action.target.host[Math.floor(Math.random() * action.target.host.length)]
-            : action.target.host;
-          
-          // Determine target port - either target port or preserve incoming port
-          const targetPort = action.target.preservePort ? record.localPort : action.target.port;
-          
           return this.setupDirectConnection(
             socket,
             record,
@@ -401,7 +461,7 @@ export class RouteConnectionHandler {
             record.lockedDomain,
             initialChunk,
             undefined,
-            targetHost,
+            selectedHost,
             targetPort
           );
           
@@ -445,14 +505,36 @@ export class RouteConnectionHandler {
         console.log(`[${connectionId}] Using basic forwarding to ${action.target.host}:${action.target.port}`);
       }
       
-      // Allow for array of hosts
-      const targetHost = Array.isArray(action.target.host) 
-        ? action.target.host[Math.floor(Math.random() * action.target.host.length)]
-        : action.target.host;
-      
-      // Determine target port - either target port or preserve incoming port
-      const targetPort = action.target.preservePort ? record.localPort : action.target.port;
-      
+      // Get the appropriate host value
+      let targetHost: string;
+
+      if (typeof action.target.host === 'function') {
+        // For function-based host, use the same routeContext created earlier
+        const hostResult = action.target.host(routeContext);
+        targetHost = Array.isArray(hostResult)
+          ? hostResult[Math.floor(Math.random() * hostResult.length)]
+          : hostResult;
+      } else {
+        // For static host value
+        targetHost = Array.isArray(action.target.host)
+          ? action.target.host[Math.floor(Math.random() * action.target.host.length)]
+          : action.target.host;
+      }
+
+      // Determine port - either function-based, static, or preserve incoming port
+      let targetPort: number;
+      if (typeof action.target.port === 'function') {
+        targetPort = action.target.port(routeContext);
+      } else if (action.target.preservePort) {
+        targetPort = record.localPort;
+      } else {
+        targetPort = action.target.port;
+      }
+
+      // Update the connection record and context with resolved values
+      record.targetHost = targetHost;
+      record.targetPort = targetPort;
+
       return this.setupDirectConnection(
         socket,
         record,
@@ -575,114 +657,8 @@ export class RouteConnectionHandler {
   }
   
   /**
-   * Handle a connection using legacy domain configuration
+   * Legacy connection handling has been removed in favor of pure route-based approach
    */
-  private handleLegacyConnection(
-    socket: plugins.net.Socket,
-    record: IConnectionRecord,
-    serverName: string,
-    domainConfig: IDomainConfig,
-    initialChunk?: Buffer
-  ): void {
-    const connectionId = record.id;
-    
-    // Get the forwarding type for this domain
-    const forwardingType = this.domainConfigManager.getForwardingType(domainConfig);
-    
-    // IP validation
-    const ipRules = this.domainConfigManager.getEffectiveIPRules(domainConfig);
-    
-    if (!this.securityManager.isIPAuthorized(record.remoteIP, ipRules.allowedIPs, ipRules.blockedIPs)) {
-      console.log(
-        `[${connectionId}] Connection rejected: IP ${record.remoteIP} not allowed for domain ${domainConfig.domains.join(', ')}`
-      );
-      socket.end();
-      this.connectionManager.initiateCleanupOnce(record, 'ip_blocked');
-      return;
-    }
-    
-    // Handle based on forwarding type
-    switch (forwardingType) {
-      case 'http-only':
-        // For HTTP-only configs with TLS traffic
-        if (record.isTLS) {
-          console.log(`[${connectionId}] Received TLS connection for HTTP-only domain ${serverName}`);
-          socket.end();
-          this.connectionManager.initiateCleanupOnce(record, 'wrong_protocol');
-          return;
-        }
-        break;
-        
-      case 'https-passthrough':
-        // For TLS passthrough with TLS traffic
-        if (record.isTLS) {
-          try {
-            const handler = this.domainConfigManager.getForwardingHandler(domainConfig);
-            
-            if (this.settings.enableDetailedLogging) {
-              console.log(`[${connectionId}] Using forwarding handler for SNI passthrough to ${serverName}`);
-            }
-            
-            // Handle the connection using the handler
-            return handler.handleConnection(socket);
-          } catch (err) {
-            console.log(`[${connectionId}] Error using forwarding handler: ${err}`);
-          }
-        }
-        break;
-        
-      case 'https-terminate-to-http':
-      case 'https-terminate-to-https':
-        // For TLS termination with TLS traffic
-        if (record.isTLS) {
-          const networkProxyPort = this.domainConfigManager.getNetworkProxyPort(domainConfig);
-          
-          if (this.settings.enableDetailedLogging) {
-            console.log(`[${connectionId}] Using TLS termination (${forwardingType}) for ${serverName} on port ${networkProxyPort}`);
-          }
-          
-          // Forward to NetworkProxy with domain-specific port
-          return this.networkProxyBridge.forwardToNetworkProxy(
-            connectionId,
-            socket,
-            record,
-            initialChunk!,
-            networkProxyPort,
-            (reason) => this.connectionManager.initiateCleanupOnce(record, reason)
-          );
-        }
-        break;
-    }
-    
-    // If we're still here, use the forwarding handler if available
-    try {
-      const handler = this.domainConfigManager.getForwardingHandler(domainConfig);
-      
-      if (this.settings.enableDetailedLogging) {
-        console.log(`[${connectionId}] Using general forwarding handler for domain ${serverName || 'unknown'}`);
-      }
-      
-      // Handle the connection using the handler
-      return handler.handleConnection(socket);
-    } catch (err) {
-      console.log(`[${connectionId}] Error using forwarding handler: ${err}`);
-    }
-    
-    // Fallback: set up direct connection
-    const targetIp = this.domainConfigManager.getTargetIP(domainConfig);
-    const targetPort = this.domainConfigManager.getTargetPort(domainConfig, this.settings.toPort);
-    
-    return this.setupDirectConnection(
-      socket,
-      record,
-      domainConfig,
-      serverName,
-      initialChunk,
-      undefined,
-      targetIp,
-      targetPort
-    );
-  }
   
   /**
    * Sets up a direct connection to the target
@@ -690,7 +666,7 @@ export class RouteConnectionHandler {
   private setupDirectConnection(
     socket: plugins.net.Socket,
     record: IConnectionRecord,
-    domainConfig?: IDomainConfig,
+    _unused?: any, // kept for backward compatibility
     serverName?: string,
     initialChunk?: Buffer,
     overridePort?: number,
@@ -698,22 +674,25 @@ export class RouteConnectionHandler {
     targetPort?: number
   ): void {
     const connectionId = record.id;
-    
+
     // Determine target host and port if not provided
-    const finalTargetHost = targetHost || (domainConfig
-      ? this.domainConfigManager.getTargetIP(domainConfig)
-      : this.settings.defaults?.target?.host
-        ? this.settings.defaults.target.host
-        : this.settings.targetIP!);
+    const finalTargetHost = targetHost ||
+      record.targetHost ||
+      (this.settings.defaults?.target?.host || 'localhost');
 
-    // Determine target port - first try explicit port, then forwarding config, then fallback
-    const finalTargetPort = targetPort || (overridePort !== undefined
-      ? overridePort
-      : domainConfig
-        ? this.domainConfigManager.getTargetPort(domainConfig, this.settings.toPort)
-        : this.settings.defaults?.target?.port
-          ? this.settings.defaults.target.port
-          : this.settings.toPort);
+    // Determine target port
+    const finalTargetPort = targetPort ||
+      record.targetPort ||
+      (overridePort !== undefined ? overridePort :
+       (this.settings.defaults?.target?.port || 443));
+
+    // Update record with final target information
+    record.targetHost = finalTargetHost;
+    record.targetPort = finalTargetPort;
+
+    if (this.settings.enableDetailedLogging) {
+      console.log(`[${connectionId}] Setting up direct connection to ${finalTargetHost}:${finalTargetPort}`);
+    }
 
     // Setup connection options
     const connectionOptions: plugins.net.NetConnectOpts = {
@@ -897,20 +876,7 @@ export class RouteConnectionHandler {
         this.connectionManager.incrementTerminationStat('outgoing', 'connection_failed');
       }
       
-      // If we have a forwarding handler for this domain, let it handle the error
-      if (domainConfig) {
-        try {
-          const forwardingHandler = this.domainConfigManager.getForwardingHandler(domainConfig);
-          forwardingHandler.emit('connection_error', {
-            socket,
-            error: err,
-            connectionId
-          });
-        } catch (handlerErr) {
-          // If getting the handler fails, just log and continue with normal cleanup
-          console.log(`Error getting forwarding handler for error handling: ${handlerErr}`);
-        }
-      }
+      // Route-based configuration doesn't use domain handlers
       
       // Clean up the connection
       this.connectionManager.initiateCleanupOnce(record, `connection_failed_${code}`);
@@ -1043,8 +1009,8 @@ export class RouteConnectionHandler {
             `${
               serverName
                 ? ` (SNI: ${serverName})`
-                : domainConfig
-                ? ` (Port-based for domain: ${domainConfig.domains.join(', ')})`
+                : record.lockedDomain
+                ? ` (Domain: ${record.lockedDomain})`
                 : ''
             }` +
             ` TLS: ${record.isTLS ? 'Yes' : 'No'}, Keep-Alive: ${
@@ -1057,8 +1023,8 @@ export class RouteConnectionHandler {
             `${
               serverName
                 ? ` (SNI: ${serverName})`
-                : domainConfig
-                ? ` (Port-based for domain: ${domainConfig.domains.join(', ')})`
+                : record.lockedDomain
+                ? ` (Domain: ${record.lockedDomain})`
                 : ''
             }`
         );