@push.rocks/smartproxy 19.5.18 → 19.5.20

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

@@ -2,14 +2,17 @@ import * as plugins from '../../plugins.js';
 import type { IConnectionRecord, ISmartProxyOptions } from './models/interfaces.js';
 import { logger } from '../../core/utils/logger.js';
 // Route checking functions have been removed
-import type { IRouteConfig, IRouteAction, IRouteContext } from './models/route-types.js';
+import type { IRouteConfig, IRouteAction } from './models/route-types.js';
+import type { IRouteContext } from '../../core/models/route-context.js';
 import { ConnectionManager } from './connection-manager.js';
 import { SecurityManager } from './security-manager.js';
 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 { SharedRouteManager as RouteManager } from '../../core/routing/route-manager.js';
 import { cleanupSocket, createIndependentSocketHandlers, setupSocketHandlers, createSocketWithErrorHandler, setupBidirectionalForwarding } from '../../core/utils/socket-utils.js';
+import { WrappedSocket } from '../../core/models/wrapped-socket.js';
+import { getUnderlyingSocket } from '../../core/models/socket-types.js';
 
 /**
  * Handles new connection processing and setup logic with support for route-based configuration
@@ -80,39 +83,52 @@ export class RouteConnectionHandler {
     const remoteIP = socket.remoteAddress || '';
     const localPort = socket.localPort || 0;
 
+    // Always wrap the socket to prepare for potential PROXY protocol
+    const wrappedSocket = new WrappedSocket(socket);
+    
+    // If this is from a trusted proxy, log it
+    if (this.settings.proxyIPs?.includes(remoteIP)) {
+      logger.log('debug', `Connection from trusted proxy ${remoteIP}, PROXY protocol parsing will be enabled`, {
+        remoteIP,
+        component: 'route-handler'
+      });
+    }
+
     // Validate IP against rate limits and connection limits
-    const ipValidation = this.securityManager.validateIP(remoteIP);
+    // Note: For wrapped sockets, this will use the underlying socket IP until PROXY protocol is parsed
+    const ipValidation = this.securityManager.validateIP(wrappedSocket.remoteAddress || '');
     if (!ipValidation.allowed) {
-      logger.log('warn', `Connection rejected`, { remoteIP, reason: ipValidation.reason, component: 'route-handler' });
-      cleanupSocket(socket, `rejected-${ipValidation.reason}`, { immediate: true });
+      logger.log('warn', `Connection rejected`, { remoteIP: wrappedSocket.remoteAddress, reason: ipValidation.reason, component: 'route-handler' });
+      cleanupSocket(wrappedSocket.socket, `rejected-${ipValidation.reason}`, { immediate: true });
       return;
     }
 
-    // Create a new connection record
-    const record = this.connectionManager.createConnection(socket);
+    // Create a new connection record with the wrapped socket
+    const record = this.connectionManager.createConnection(wrappedSocket);
     if (!record) {
       // Connection was rejected due to limit - socket already destroyed by connection manager
       return;
     }
     const connectionId = record.id;
 
-    // Apply socket optimizations
-    socket.setNoDelay(this.settings.noDelay);
+    // Apply socket optimizations (apply to underlying socket)
+    const underlyingSocket = wrappedSocket.socket;
+    underlyingSocket.setNoDelay(this.settings.noDelay);
 
     // Apply keep-alive settings if enabled
     if (this.settings.keepAlive) {
-      socket.setKeepAlive(true, this.settings.keepAliveInitialDelay);
+      underlyingSocket.setKeepAlive(true, this.settings.keepAliveInitialDelay);
       record.hasKeepAlive = true;
 
       // Apply enhanced TCP keep-alive options if enabled
       if (this.settings.enableKeepAliveProbes) {
         try {
           // These are platform-specific and may not be available
-          if ('setKeepAliveProbes' in socket) {
-            (socket as any).setKeepAliveProbes(10);
+          if ('setKeepAliveProbes' in underlyingSocket) {
+            (underlyingSocket as any).setKeepAliveProbes(10);
           }
-          if ('setKeepAliveInterval' in socket) {
-            (socket as any).setKeepAliveInterval(1000);
+          if ('setKeepAliveInterval' in underlyingSocket) {
+            (underlyingSocket as any).setKeepAliveInterval(1000);
           }
         } catch (err) {
           // Ignore errors - these are optional enhancements
@@ -150,19 +166,19 @@ export class RouteConnectionHandler {
     }
 
     // Handle the connection - wait for initial data to determine if it's TLS
-    this.handleInitialData(socket, record);
+    this.handleInitialData(wrappedSocket, record);
   }
 
   /**
    * Handle initial data from a connection to determine routing
    */
-  private handleInitialData(socket: plugins.net.Socket, record: IConnectionRecord): void {
+  private handleInitialData(socket: plugins.net.Socket | WrappedSocket, record: IConnectionRecord): void {
     const connectionId = record.id;
     const localPort = record.localPort;
     let initialDataReceived = false;
 
     // Check if any routes on this port require TLS handling
-    const allRoutes = this.routeManager.getAllRoutes();
+    const allRoutes = this.routeManager.getRoutes();
     const needsTlsHandling = allRoutes.some(route => {
       // Check if route matches this port
       const matchesPort = this.routeManager.getRoutesForPort(localPort).includes(route);
@@ -176,9 +192,11 @@ export class RouteConnectionHandler {
 
     // If no routes require TLS handling and it's not port 443, route immediately
     if (!needsTlsHandling && localPort !== 443) {
+      // Extract underlying socket for socket-utils functions
+      const underlyingSocket = getUnderlyingSocket(socket);
       // Set up proper socket handlers for immediate routing
       setupSocketHandlers(
-        socket,
+        underlyingSocket,
         (reason) => {
           // Only cleanup if connection hasn't been fully established
           // Check if outgoing connection exists and is connected
@@ -370,7 +388,7 @@ export class RouteConnectionHandler {
    * Route the connection based on match criteria
    */
   private routeConnection(
-    socket: plugins.net.Socket,
+    socket: plugins.net.Socket | WrappedSocket,
     record: IConnectionRecord,
     serverName: string,
     initialChunk?: Buffer
@@ -385,15 +403,21 @@ export class RouteConnectionHandler {
     // For HTTP proxy ports without TLS, skip domain check since domain info comes from HTTP headers
     const skipDomainCheck = isHttpProxyPort && !record.isTLS;
 
-    // Find matching route
-    const routeMatch = this.routeManager.findMatchingRoute({
+    // Create route context for matching
+    const routeContext: IRouteContext = {
       port: localPort,
-      domain: serverName,
+      domain: skipDomainCheck ? undefined : serverName, // Skip domain if HTTP proxy without TLS
       clientIp: remoteIP,
+      serverIp: socket.localAddress || '',
       path: undefined, // We don't have path info at this point
+      isTls: record.isTLS,
       tlsVersion: undefined, // We don't extract TLS version yet
-      skipDomainCheck: skipDomainCheck,
-    });
+      timestamp: Date.now(),
+      connectionId: record.id
+    };
+
+    // Find matching route
+    const routeMatch = this.routeManager.findMatchingRoute(routeContext);
 
     if (!routeMatch) {
       logger.log('warn', `No route found for ${serverName || 'connection'} on port ${localPort} (connection: ${connectionId})`, {
@@ -552,7 +576,7 @@ export class RouteConnectionHandler {
    * Handle a forward action for a route
    */
   private handleForwardAction(
-    socket: plugins.net.Socket,
+    socket: plugins.net.Socket | WrappedSocket,
     record: IConnectionRecord,
     route: IRouteConfig,
     initialChunk?: Buffer
@@ -869,7 +893,7 @@ export class RouteConnectionHandler {
    * Handle a socket-handler action for a route
    */
   private async handleSocketHandlerAction(
-    socket: plugins.net.Socket,
+    socket: plugins.net.Socket | WrappedSocket,
     record: IConnectionRecord,
     route: IRouteConfig,
     initialChunk?: Buffer
@@ -933,8 +957,9 @@ export class RouteConnectionHandler {
     });
     
     try {
-      // Call the handler with socket AND context
-      const result = route.action.socketHandler(socket, routeContext);
+      // Call the handler with the appropriate socket (extract underlying if needed)
+      const handlerSocket = getUnderlyingSocket(socket);
+      const result = route.action.socketHandler(handlerSocket, routeContext);
       
       // Handle async handlers properly
       if (result instanceof Promise) {
@@ -988,7 +1013,7 @@ export class RouteConnectionHandler {
    * Sets up a direct connection to the target
    */
   private setupDirectConnection(
-    socket: plugins.net.Socket,
+    socket: plugins.net.Socket | WrappedSocket,
     record: IConnectionRecord,
     serverName?: string,
     initialChunk?: Buffer,
@@ -1138,7 +1163,10 @@ export class RouteConnectionHandler {
         }
 
         // Use centralized bidirectional forwarding setup
-        setupBidirectionalForwarding(socket, targetSocket, {
+        // Extract underlying sockets for socket-utils functions
+        const incomingSocket = getUnderlyingSocket(socket);
+        
+        setupBidirectionalForwarding(incomingSocket, targetSocket, {
           onClientData: (chunk) => {
             record.bytesReceived += chunk.length;
             this.timeoutManager.updateActivity(record);

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

@@ -8,7 +8,7 @@ import { TlsManager } from './tls-manager.js';
 import { HttpProxyBridge } from './http-proxy-bridge.js';
 import { TimeoutManager } from './timeout-manager.js';
 import { PortManager } from './port-manager.js';
-import { RouteManager } from './route-manager.js';
+import { SharedRouteManager as RouteManager } from '../../core/routing/route-manager.js';
 import { RouteConnectionHandler } from './route-connection-handler.js';
 import { NFTablesManager } from './nftables-manager.js';
 
@@ -162,8 +162,20 @@ export class SmartProxy extends plugins.EventEmitter {
       this.timeoutManager
     );
     
-    // Create the route manager
-    this.routeManager = new RouteManager(this.settings);
+    // Create the route manager with SharedRouteManager API
+    // Create a logger adapter to match ILogger interface
+    const loggerAdapter = {
+      debug: (message: string, data?: any) => logger.log('debug', message, data),
+      info: (message: string, data?: any) => logger.log('info', message, data),
+      warn: (message: string, data?: any) => logger.log('warn', message, data),
+      error: (message: string, data?: any) => logger.log('error', message, data)
+    };
+    
+    this.routeManager = new RouteManager({
+      logger: loggerAdapter,
+      enableDetailedLogging: this.settings.enableDetailedLogging,
+      routes: this.settings.routes
+    });
 
     
     // Create other required components

package/ts/proxies/smart-proxy/utils/route-utils.ts

@@ -92,6 +92,8 @@ export function mergeRouteConfigs(
   return mergedRoute;
 }
 
+import { DomainMatcher, PathMatcher, HeaderMatcher } from '../../../core/routing/matchers/index.js';
+
 /**
  * Check if a route matches a domain
  * @param route The route to check
@@ -107,14 +109,7 @@ export function routeMatchesDomain(route: IRouteConfig, domain: string): boolean
     ? route.match.domains 
     : [route.match.domains];
   
-  return domains.some(d => {
-    // Handle wildcard domains
-    if (d.startsWith('*.')) {
-      const suffix = d.substring(2);
-      return domain.endsWith(suffix) && domain.split('.').length > suffix.split('.').length;
-    }
-    return d.toLowerCase() === domain.toLowerCase();
-  });
+  return domains.some(d => DomainMatcher.match(d, domain));
 }
 
 /**
@@ -160,28 +155,7 @@ export function routeMatchesPath(route: IRouteConfig, path: string): boolean {
     return true; // No path specified means it matches any path
   }
   
-  // Handle exact path
-  if (route.match.path === path) {
-    return true;
-  }
-  
-  // Handle path prefix with trailing slash (e.g., /api/)
-  if (route.match.path.endsWith('/') && path.startsWith(route.match.path)) {
-    return true;
-  }
-  
-  // Handle exact path match without trailing slash
-  if (!route.match.path.endsWith('/') && path === route.match.path) {
-    return true;
-  }
-  
-  // Handle wildcard paths (e.g., /api/*)
-  if (route.match.path.endsWith('*')) {
-    const prefix = route.match.path.slice(0, -1);
-    return path.startsWith(prefix);
-  }
-  
-  return false;
+  return PathMatcher.match(route.match.path, path).matches;
 }
 
 /**
@@ -198,25 +172,13 @@ export function routeMatchesHeaders(
     return true; // No headers specified means it matches any headers
   }
   
-  // Check each header in the route's match criteria
-  return Object.entries(route.match.headers).every(([key, value]) => {
-    // If the header isn't present in the request, it doesn't match
-    if (!headers[key]) {
-      return false;
-    }
-    
-    // Handle exact match
-    if (typeof value === 'string') {
-      return headers[key] === value;
-    }
-    
-    // Handle regex match
-    if (value instanceof RegExp) {
-      return value.test(headers[key]);
-    }
-    
-    return false;
-  });
+  // Convert RegExp patterns to strings for HeaderMatcher
+  const stringHeaders: Record<string, string> = {};
+  for (const [key, value] of Object.entries(route.match.headers)) {
+    stringHeaders[key] = value instanceof RegExp ? value.source : value;
+  }
+  
+  return HeaderMatcher.matchAll(stringHeaders, headers);
 }
 
 /**

package/ts/routing/router/http-router.ts

@@ -0,0 +1,266 @@
+import * as plugins from '../../plugins.js';
+import type { IRouteConfig } from '../../proxies/smart-proxy/models/route-types.js';
+import { DomainMatcher, PathMatcher } from '../../core/routing/matchers/index.js';
+
+/**
+ * Interface for router result with additional metadata
+ */
+export interface RouterResult {
+  route: IRouteConfig;
+  pathMatch?: string;
+  pathParams?: Record<string, string>;
+  pathRemainder?: string;
+}
+
+
+/**
+ * Logger interface for HttpRouter
+ */
+export interface ILogger {
+  debug?: (message: string, data?: any) => void;
+  info: (message: string, data?: any) => void;
+  warn: (message: string, data?: any) => void;
+  error: (message: string, data?: any) => void;
+}
+
+/**
+ * Unified HTTP Router for reverse proxy requests
+ * 
+ * Domain matching patterns:
+ * - Exact matches: "example.com"
+ * - Wildcard subdomains: "*.example.com" (matches any subdomain of example.com)
+ * - TLD wildcards: "example.*" (matches example.com, example.org, etc.)
+ * - Complex wildcards: "*.lossless*" (matches any subdomain of any lossless domain)
+ * - Default fallback: "*" (matches any unmatched domain)
+ * 
+ * Path pattern matching:
+ * - Exact path: "/api/users"
+ * - Wildcard paths: "/api/*" 
+ * - Path parameters: "/users/:id/profile"
+ */
+export class HttpRouter {
+  // Store routes sorted by priority
+  private routes: IRouteConfig[] = [];
+  // Default route to use when no match is found (optional)
+  private defaultRoute?: IRouteConfig;
+  // Logger interface
+  private logger: ILogger;
+
+  constructor(
+    routes?: IRouteConfig[],
+    logger?: ILogger
+  ) {
+    this.logger = logger || {
+      error: console.error.bind(console),
+      warn: console.warn.bind(console),
+      info: console.info.bind(console),
+      debug: console.debug?.bind(console)
+    };
+    
+    if (routes) {
+      this.setRoutes(routes);
+    }
+  }
+
+  /**
+   * Sets a new set of routes
+   * @param routes Array of route configurations
+   */
+  public setRoutes(routes: IRouteConfig[]): void {
+    this.routes = [...routes];
+
+    // Sort routes by priority (higher priority first)
+    this.routes.sort((a, b) => {
+      const priorityA = a.priority ?? 0;
+      const priorityB = b.priority ?? 0;
+      return priorityB - priorityA;
+    });
+
+    // Find default route if any (route with "*" as domain)
+    this.defaultRoute = this.routes.find(route => {
+      const domains = Array.isArray(route.match.domains) 
+        ? route.match.domains 
+        : route.match.domains ? [route.match.domains] : [];
+      return domains.includes('*');
+    });
+
+    const uniqueDomains = this.getHostnames();
+    this.logger.info(`HttpRouter initialized with ${this.routes.length} routes (${uniqueDomains.length} unique hosts)`);
+  }
+
+  /**
+   * Routes a request based on hostname and path
+   * @param req The incoming HTTP request
+   * @returns The matching route or undefined if no match found
+   */
+  public routeReq(req: plugins.http.IncomingMessage): IRouteConfig | undefined {
+    const result = this.routeReqWithDetails(req);
+    return result ? result.route : undefined;
+  }
+
+  /**
+   * Routes a request with detailed matching information
+   * @param req The incoming HTTP request
+   * @returns Detailed routing result including matched route and path information
+   */
+  public routeReqWithDetails(req: plugins.http.IncomingMessage): RouterResult | undefined {
+    // Extract and validate host header
+    const originalHost = req.headers.host;
+    if (!originalHost) {
+      this.logger.error('No host header found in request');
+      return this.defaultRoute ? { route: this.defaultRoute } : undefined;
+    }
+    
+    // Parse URL for path matching
+    const parsedUrl = plugins.url.parse(req.url || '/');
+    const urlPath = parsedUrl.pathname || '/';
+    
+    // Extract hostname without port
+    const hostWithoutPort = originalHost.split(':')[0].toLowerCase();
+    
+    // Find matching route
+    const matchingRoute = this.findMatchingRoute(hostWithoutPort, urlPath);
+    
+    if (matchingRoute) {
+      return matchingRoute;
+    }
+    
+    // Fall back to default route if available
+    if (this.defaultRoute) {
+      this.logger.warn(`No specific route found for host: ${hostWithoutPort}, using default`);
+      return { route: this.defaultRoute };
+    }
+    
+    this.logger.error(`No route found for host: ${hostWithoutPort}`);
+    return undefined;
+  }
+
+  /**
+   * Find the best matching route for a given hostname and path
+   */
+  private findMatchingRoute(hostname: string, path: string): RouterResult | undefined {
+    // Try each route in priority order
+    for (const route of this.routes) {
+      // Skip disabled routes
+      if (route.enabled === false) {
+        continue;
+      }
+
+      // Check domain match
+      if (route.match.domains) {
+        const domains = Array.isArray(route.match.domains) 
+          ? route.match.domains 
+          : [route.match.domains];
+        
+        // Check if any domain pattern matches
+        const domainMatches = domains.some(domain => 
+          DomainMatcher.match(domain, hostname)
+        );
+        
+        if (!domainMatches) {
+          continue;
+        }
+      }
+
+      // Check path match if specified
+      if (route.match.path) {
+        const pathResult = PathMatcher.match(route.match.path, path);
+        if (pathResult.matches) {
+          return {
+            route,
+            pathMatch: path,
+            pathParams: pathResult.params,
+            pathRemainder: pathResult.pathRemainder
+          };
+        }
+      } else {
+        // No path specified, so domain match is sufficient
+        return { route };
+      }
+    }
+    
+    return undefined;
+  }
+
+  /**
+   * Gets all currently active route configurations
+   * @returns Array of all active routes
+   */
+  public getRoutes(): IRouteConfig[] {
+    return [...this.routes];
+  }
+
+  /**
+   * Gets all hostnames that this router is configured to handle
+   * @returns Array of unique hostnames
+   */
+  public getHostnames(): string[] {
+    const hostnames = new Set<string>();
+    for (const route of this.routes) {
+      if (!route.match.domains) continue;
+      
+      const domains = Array.isArray(route.match.domains) 
+        ? route.match.domains 
+        : [route.match.domains];
+      
+      for (const domain of domains) {
+        if (domain !== '*') {
+          hostnames.add(domain.toLowerCase());
+        }
+      }
+    }
+    return Array.from(hostnames);
+  }
+
+  /**
+   * Adds a single new route configuration
+   * @param route The route configuration to add
+   */
+  public addRoute(route: IRouteConfig): void {
+    this.routes.push(route);
+    
+    // Re-sort routes by priority
+    this.routes.sort((a, b) => {
+      const priorityA = a.priority ?? 0;
+      const priorityB = b.priority ?? 0;
+      return priorityB - priorityA;
+    });
+  }
+
+  /**
+   * Removes routes by domain pattern
+   * @param domain The domain pattern to remove routes for
+   * @returns Boolean indicating whether any routes were removed
+   */
+  public removeRoutesByDomain(domain: string): boolean {
+    const initialCount = this.routes.length;
+    
+    // Filter out routes that match the domain
+    this.routes = this.routes.filter(route => {
+      if (!route.match.domains) return true;
+      
+      const domains = Array.isArray(route.match.domains) 
+        ? route.match.domains 
+        : [route.match.domains];
+      
+      return !domains.includes(domain);
+    });
+    
+    return this.routes.length !== initialCount;
+  }
+
+  /**
+   * Remove a specific route by reference
+   * @param route The route to remove
+   * @returns Boolean indicating if the route was found and removed
+   */
+  public removeRoute(route: IRouteConfig): boolean {
+    const index = this.routes.indexOf(route);
+    if (index !== -1) {
+      this.routes.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+
+}

package/ts/routing/router/index.ts

@@ -2,11 +2,6 @@
  * HTTP routing
  */
 
-// Export selectively to avoid ambiguity between duplicate type names
-export { ProxyRouter } from './proxy-router.js';
-export type { IPathPatternConfig } from './proxy-router.js';
-// Re-export the RouterResult and PathPatternConfig from proxy-router.js (legacy names maintained for compatibility)
-export type { PathPatternConfig as ProxyPathPatternConfig, RouterResult as ProxyRouterResult } from './proxy-router.js';
-
-export { RouteRouter } from './route-router.js';
-export type { PathPatternConfig as RoutePathPatternConfig, RouterResult as RouteRouterResult } from './route-router.js';
+// Export the unified HttpRouter
+export { HttpRouter } from './http-router.js';
+export type { RouterResult, ILogger } from './http-router.js';