@push.rocks/smartproxy 22.4.2 → 23.0.0

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

@@ -1,271 +0,0 @@
-import * as plugins from '../../plugins.js';
-import { NfTablesProxy } from '../nftables-proxy/nftables-proxy.js';
-import type { 
-  NfTableProxyOptions, 
-  PortRange,
-  NfTablesStatus
-} from '../nftables-proxy/models/interfaces.js';
-import type {
-  IRouteConfig,
-  TPortRange,
-  INfTablesOptions
-} from './models/route-types.js';
-import type { SmartProxy } from './smart-proxy.js';
-
-/**
- * Manages NFTables rules based on SmartProxy route configurations
- * 
- * This class bridges the gap between SmartProxy routes and the NFTablesProxy,
- * allowing high-performance kernel-level packet forwarding for routes that 
- * specify NFTables as their forwarding engine.
- */
-export class NFTablesManager {
-  private rulesMap: Map<string, NfTablesProxy> = new Map();
-  
-  /**
-   * Creates a new NFTablesManager
-   * 
-   * @param smartProxy The SmartProxy instance
-   */
-  constructor(private smartProxy: SmartProxy) {}
-  
-  /**
-   * Provision NFTables rules for a route
-   * 
-   * @param route The route configuration
-   * @returns A promise that resolves to true if successful, false otherwise
-   */
-  public async provisionRoute(route: IRouteConfig): Promise<boolean> {
-    // Generate a unique ID for this route
-    const routeId = this.generateRouteId(route);
-    
-    // Skip if route doesn't use NFTables
-    if (route.action.forwardingEngine !== 'nftables') {
-      return true;
-    }
-    
-    // Create NFTables options from route configuration
-    const nftOptions = this.createNfTablesOptions(route);
-    
-    // Create and start an NFTablesProxy instance
-    const proxy = new NfTablesProxy(nftOptions);
-    
-    try {
-      await proxy.start();
-      this.rulesMap.set(routeId, proxy);
-      return true;
-    } catch (err) {
-      console.error(`Failed to provision NFTables rules for route ${route.name || 'unnamed'}: ${err.message}`);
-      return false;
-    }
-  }
-  
-  /**
-   * Remove NFTables rules for a route
-   * 
-   * @param route The route configuration
-   * @returns A promise that resolves to true if successful, false otherwise
-   */
-  public async deprovisionRoute(route: IRouteConfig): Promise<boolean> {
-    const routeId = this.generateRouteId(route);
-    
-    const proxy = this.rulesMap.get(routeId);
-    if (!proxy) {
-      return true; // Nothing to remove
-    }
-    
-    try {
-      await proxy.stop();
-      this.rulesMap.delete(routeId);
-      return true;
-    } catch (err) {
-      console.error(`Failed to deprovision NFTables rules for route ${route.name || 'unnamed'}: ${err.message}`);
-      return false;
-    }
-  }
-  
-  /**
-   * Update NFTables rules when route changes
-   * 
-   * @param oldRoute The previous route configuration
-   * @param newRoute The new route configuration
-   * @returns A promise that resolves to true if successful, false otherwise
-   */
-  public async updateRoute(oldRoute: IRouteConfig, newRoute: IRouteConfig): Promise<boolean> {
-    // Remove old rules and add new ones
-    await this.deprovisionRoute(oldRoute);
-    return this.provisionRoute(newRoute);
-  }
-  
-  /**
-   * Generate a unique ID for a route
-   * 
-   * @param route The route configuration
-   * @returns A unique ID string
-   */
-  private generateRouteId(route: IRouteConfig): string {
-    // Generate a unique ID based on route properties
-    // Include the route name, match criteria, and a timestamp
-    const matchStr = JSON.stringify({
-      ports: route.match.ports,
-      domains: route.match.domains
-    });
-    
-    return `${route.name || 'unnamed'}-${matchStr}-${route.id || Date.now().toString()}`;
-  }
-  
-  /**
-   * Create NFTablesProxy options from a route configuration
-   * 
-   * @param route The route configuration
-   * @returns NFTableProxyOptions object
-   */
-  private createNfTablesOptions(route: IRouteConfig): NfTableProxyOptions {
-    const { action } = route;
-    
-    // Ensure we have targets
-    if (!action.targets || action.targets.length === 0) {
-      throw new Error('Route must have targets to use NFTables forwarding');
-    }
-    
-    // NFTables can only handle a single target, so we use the first target without match criteria
-    // or the first target if all have match criteria
-    const defaultTarget = action.targets.find(t => !t.match) || action.targets[0];
-    
-    // Convert port specifications
-    const fromPorts = this.expandPortRange(route.match.ports);
-    
-    // Determine target port
-    let toPorts: number | PortRange | Array<number | PortRange>;
-    
-    if (defaultTarget.port === 'preserve') {
-      // 'preserve' means use the same ports as the source
-      toPorts = fromPorts;
-    } else if (typeof defaultTarget.port === 'function') {
-      // For function-based ports, we can't determine at setup time
-      // Use the "preserve" approach and let NFTables handle it
-      toPorts = fromPorts;
-    } else {
-      toPorts = defaultTarget.port;
-    }
-    
-    // Determine target host
-    let toHost: string;
-    if (typeof defaultTarget.host === 'function') {
-      // Can't determine at setup time, use localhost as a placeholder
-      // and rely on run-time handling
-      toHost = 'localhost';
-    } else if (Array.isArray(defaultTarget.host)) {
-      // Use first host for now - NFTables will do simple round-robin  
-      toHost = defaultTarget.host[0];
-    } else {
-      toHost = defaultTarget.host;
-    }
-    
-    // Create options
-    const options: NfTableProxyOptions = {
-      fromPort: fromPorts,
-      toPort: toPorts,
-      toHost: toHost,
-      protocol: action.nftables?.protocol || 'tcp',
-      preserveSourceIP: action.nftables?.preserveSourceIP !== undefined ? 
-                        action.nftables.preserveSourceIP : 
-                        this.smartProxy.settings.preserveSourceIP,
-      useIPSets: action.nftables?.useIPSets !== false,
-      useAdvancedNAT: action.nftables?.useAdvancedNAT,
-      enableLogging: this.smartProxy.settings.enableDetailedLogging,
-      deleteOnExit: true,
-      tableName: action.nftables?.tableName || 'smartproxy'
-    };
-    
-    // Add security-related options
-    if (route.security?.ipAllowList?.length) {
-      options.ipAllowList = route.security.ipAllowList;
-    }
-    
-    if (route.security?.ipBlockList?.length) {
-      options.ipBlockList = route.security.ipBlockList;
-    }
-    
-    // Add QoS options
-    if (action.nftables?.maxRate || action.nftables?.priority) {
-      options.qos = {
-        enabled: true,
-        maxRate: action.nftables.maxRate,
-        priority: action.nftables.priority
-      };
-    }
-    
-    return options;
-  }
-  
-  /**
-   * Expand port range specifications
-   * 
-   * @param ports The port range specification
-   * @returns Expanded port range
-   */
-  private expandPortRange(ports: TPortRange): number | PortRange | Array<number | PortRange> {
-    // Process different port specifications
-    if (typeof ports === 'number') {
-      return ports;
-    } else if (Array.isArray(ports)) {
-      const result: Array<number | PortRange> = [];
-      
-      for (const item of ports) {
-        if (typeof item === 'number') {
-          result.push(item);
-        } else if ('from' in item && 'to' in item) {
-          result.push({ from: item.from, to: item.to });
-        }
-      }
-      
-      return result;
-    } else if (typeof ports === 'object' && ports !== null && 'from' in ports && 'to' in ports) {
-      return { from: (ports as any).from, to: (ports as any).to };
-    }
-    
-    // Fallback to port 80 if something went wrong
-    console.warn('Invalid port range specification, using port 80 as fallback');
-    return 80;
-  }
-  
-  /**
-   * Get status of all managed rules
-   * 
-   * @returns A promise that resolves to a record of NFTables status objects
-   */
-  public async getStatus(): Promise<Record<string, NfTablesStatus>> {
-    const result: Record<string, NfTablesStatus> = {};
-    
-    for (const [routeId, proxy] of this.rulesMap.entries()) {
-      result[routeId] = await proxy.getStatus();
-    }
-    
-    return result;
-  }
-  
-  /**
-   * Check if a route is currently provisioned
-   * 
-   * @param route The route configuration
-   * @returns True if the route is provisioned, false otherwise
-   */
-  public isRouteProvisioned(route: IRouteConfig): boolean {
-    const routeId = this.generateRouteId(route);
-    return this.rulesMap.has(routeId);
-  }
-  
-  /**
-   * Stop all NFTables rules
-   * 
-   * @returns A promise that resolves when all rules have been stopped
-   */
-  public async stop(): Promise<void> {
-    // Stop all NFTables proxies
-    const stopPromises = Array.from(this.rulesMap.values()).map(proxy => proxy.stop());
-    await Promise.all(stopPromises);
-    
-    this.rulesMap.clear();
-  }
-}

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

@@ -1,358 +0,0 @@
-import * as plugins from '../../plugins.js';
-import { logger } from '../../core/utils/logger.js';
-import { cleanupSocket } from '../../core/utils/socket-utils.js';
-import type { SmartProxy } from './smart-proxy.js';
-
-/**
- * PortManager handles the dynamic creation and removal of port listeners
- * 
- * This class provides methods to add and remove listening ports at runtime,
- * allowing SmartProxy to adapt to configuration changes without requiring
- * a full restart.
- * 
- * It includes a reference counting system to track how many routes are using
- * each port, so ports can be automatically released when they are no longer needed.
- */
-export class PortManager {
-  private servers: Map<number, plugins.net.Server> = new Map();
-  private isShuttingDown: boolean = false;
-  // Track how many routes are using each port
-  private portRefCounts: Map<number, number> = new Map();
-
-  /**
-   * Create a new PortManager
-   * 
-   * @param smartProxy The SmartProxy instance
-   */
-  constructor(
-    private smartProxy: SmartProxy
-  ) {}
-
-  /**
-   * Start listening on a specific port
-   * 
-   * @param port The port number to listen on
-   * @returns Promise that resolves when the server is listening or rejects on error
-   */
-  public async addPort(port: number): Promise<void> {
-    // Check if we're already listening on this port
-    if (this.servers.has(port)) {
-      // Port is already bound, just increment the reference count
-      this.incrementPortRefCount(port);
-      try {
-        logger.log('debug', `PortManager: Port ${port} is already bound by SmartProxy, reusing binding`, { 
-          port,
-          component: 'port-manager'
-        });
-      } catch (e) {
-        console.log(`[DEBUG] PortManager: Port ${port} is already bound by SmartProxy, reusing binding`);
-      }
-      return;
-    }
-
-    // Initialize reference count for new port
-    this.portRefCounts.set(port, 1);
-
-    // Create a server for this port
-    const server = plugins.net.createServer((socket) => {
-      // Check if shutting down
-      if (this.isShuttingDown) {
-        cleanupSocket(socket, 'port-manager-shutdown', { immediate: true });
-        return;
-      }
-      
-      // Delegate to route connection handler
-      this.smartProxy.routeConnectionHandler.handleConnection(socket);
-    }).on('error', (err: Error) => {
-      try {
-        logger.log('error', `Server Error on port ${port}: ${err.message}`, {
-          port,
-          error: err.message,
-          component: 'port-manager'
-        });
-      } catch (e) {
-        console.error(`[ERROR] Server Error on port ${port}: ${err.message}`);
-      }
-    });
-    
-    // Start listening on the port
-    return new Promise<void>((resolve, reject) => {
-      server.listen(port, () => {
-        const isHttpProxyPort = this.smartProxy.settings.useHttpProxy?.includes(port);
-        try {
-          logger.log('info', `SmartProxy -> OK: Now listening on port ${port}${
-            isHttpProxyPort ? ' (HttpProxy forwarding enabled)' : ''
-          }`, {
-            port,
-            isHttpProxyPort: !!isHttpProxyPort,
-            component: 'port-manager'
-          });
-        } catch (e) {
-          console.log(`[INFO] SmartProxy -> OK: Now listening on port ${port}${
-            isHttpProxyPort ? ' (HttpProxy forwarding enabled)' : ''
-          }`);
-        }
-        
-        // Store the server reference
-        this.servers.set(port, server);
-        resolve();
-      }).on('error', (err) => {
-        // Check if this is an external conflict
-        const { isConflict, isExternal } = this.isPortConflict(err);
-        
-        if (isConflict && !isExternal) {
-          // This is an internal conflict (port already bound by SmartProxy)
-          // This shouldn't normally happen because we check servers.has(port) above
-          logger.log('warn', `Port ${port} binding conflict: already in use by SmartProxy`, {
-            port,
-            component: 'port-manager'
-          });
-          // Still increment reference count to maintain tracking
-          this.incrementPortRefCount(port);
-          resolve();
-          return;
-        }
-        
-        // Log the error and propagate it
-        logger.log('error', `Failed to listen on port ${port}: ${err.message}`, {
-          port,
-          error: err.message,
-          code: (err as any).code,
-          component: 'port-manager'
-        });
-        
-        // Clean up reference count since binding failed
-        this.portRefCounts.delete(port);
-        
-        reject(err);
-      });
-    });
-  }
-
-  /**
-   * Stop listening on a specific port
-   * 
-   * @param port The port to stop listening on
-   * @returns Promise that resolves when the server is closed
-   */
-  public async removePort(port: number): Promise<void> {
-    // Decrement the reference count first
-    const newRefCount = this.decrementPortRefCount(port);
-    
-    // If there are still references to this port, keep it open
-    if (newRefCount > 0) {
-      logger.log('debug', `PortManager: Port ${port} still has ${newRefCount} references, keeping open`, {
-        port,
-        refCount: newRefCount,
-        component: 'port-manager'
-      });
-      return;
-    }
-
-    // Get the server for this port
-    const server = this.servers.get(port);
-    if (!server) {
-      logger.log('warn', `PortManager: Not listening on port ${port}`, {
-        port,
-        component: 'port-manager'
-      });
-      // Ensure reference count is reset
-      this.portRefCounts.delete(port);
-      return;
-    }
-
-    // Close the server
-    return new Promise<void>((resolve) => {
-      server.close((err) => {
-        if (err) {
-          logger.log('error', `Error closing server on port ${port}: ${err.message}`, {
-            port,
-            error: err.message,
-            component: 'port-manager'
-          });
-        } else {
-          logger.log('info', `SmartProxy -> Stopped listening on port ${port}`, {
-            port,
-            component: 'port-manager'
-          });
-        }
-        
-        // Remove the server reference and clean up reference counting
-        this.servers.delete(port);
-        this.portRefCounts.delete(port);
-        resolve();
-      });
-    });
-  }
-
-  /**
-   * Add multiple ports at once
-   * 
-   * @param ports Array of ports to add
-   * @returns Promise that resolves when all servers are listening
-   */
-  public async addPorts(ports: number[]): Promise<void> {
-    const uniquePorts = [...new Set(ports)];
-    await Promise.all(uniquePorts.map(port => this.addPort(port)));
-  }
-
-  /**
-   * Remove multiple ports at once
-   * 
-   * @param ports Array of ports to remove
-   * @returns Promise that resolves when all servers are closed
-   */
-  public async removePorts(ports: number[]): Promise<void> {
-    const uniquePorts = [...new Set(ports)];
-    await Promise.all(uniquePorts.map(port => this.removePort(port)));
-  }
-
-  /**
-   * Update listening ports to match the provided list
-   * 
-   * This will add any ports that aren't currently listening,
-   * and remove any ports that are no longer needed.
-   * 
-   * @param ports Array of ports that should be listening
-   * @returns Promise that resolves when all operations are complete
-   */
-  public async updatePorts(ports: number[]): Promise<void> {
-    const targetPorts = new Set(ports);
-    const currentPorts = new Set(this.servers.keys());
-    
-    // Find ports to add and remove
-    const portsToAdd = ports.filter(port => !currentPorts.has(port));
-    const portsToRemove = Array.from(currentPorts).filter(port => !targetPorts.has(port));
-    
-    // Log the changes
-    if (portsToAdd.length > 0) {
-      console.log(`PortManager: Adding new listeners for ports: ${portsToAdd.join(', ')}`);
-    }
-    
-    if (portsToRemove.length > 0) {
-      console.log(`PortManager: Removing listeners for ports: ${portsToRemove.join(', ')}`);
-    }
-    
-    // Add and remove ports
-    await this.removePorts(portsToRemove);
-    await this.addPorts(portsToAdd);
-  }
-
-  /**
-   * Get all ports that are currently listening
-   * 
-   * @returns Array of port numbers
-   */
-  public getListeningPorts(): number[] {
-    return Array.from(this.servers.keys());
-  }
-
-  /**
-   * Mark the port manager as shutting down
-   */
-  public setShuttingDown(isShuttingDown: boolean): void {
-    this.isShuttingDown = isShuttingDown;
-  }
-
-  /**
-   * Close all listening servers
-   * 
-   * @returns Promise that resolves when all servers are closed
-   */
-  public async closeAll(): Promise<void> {
-    const allPorts = Array.from(this.servers.keys());
-    await this.removePorts(allPorts);
-  }
-
-  /**
-   * Get all server instances (for testing or debugging)
-   */
-  public getServers(): Map<number, plugins.net.Server> {
-    return new Map(this.servers);
-  }
-
-  /**
-   * Check if a port is bound by this SmartProxy instance
-   * 
-   * @param port The port number to check
-   * @returns True if the port is currently bound by SmartProxy
-   */
-  public isPortBoundBySmartProxy(port: number): boolean {
-    return this.servers.has(port);
-  }
-
-  /**
-   * Get the current reference count for a port
-   * 
-   * @param port The port number to check
-   * @returns The number of routes using this port, 0 if none
-   */
-  public getPortRefCount(port: number): number {
-    return this.portRefCounts.get(port) || 0;
-  }
-
-  /**
-   * Increment the reference count for a port
-   * 
-   * @param port The port number to increment
-   * @returns The new reference count
-   */
-  public incrementPortRefCount(port: number): number {
-    const currentCount = this.portRefCounts.get(port) || 0;
-    const newCount = currentCount + 1;
-    this.portRefCounts.set(port, newCount);
-    
-    logger.log('debug', `Port ${port} reference count increased to ${newCount}`, { 
-      port, 
-      refCount: newCount,
-      component: 'port-manager' 
-    });
-    
-    return newCount;
-  }
-
-  /**
-   * Decrement the reference count for a port
-   * 
-   * @param port The port number to decrement
-   * @returns The new reference count
-   */
-  public decrementPortRefCount(port: number): number {
-    const currentCount = this.portRefCounts.get(port) || 0;
-    
-    if (currentCount <= 0) {
-      logger.log('warn', `Attempted to decrement reference count for port ${port} below zero`, { 
-        port,
-        component: 'port-manager'
-      });
-      return 0;
-    }
-    
-    const newCount = currentCount - 1;
-    this.portRefCounts.set(port, newCount);
-    
-    logger.log('debug', `Port ${port} reference count decreased to ${newCount}`, { 
-      port, 
-      refCount: newCount,
-      component: 'port-manager'
-    });
-    
-    return newCount;
-  }
-
-  /**
-   * Determine if a port binding error is due to an external or internal conflict
-   * 
-   * @param error The error object from a failed port binding
-   * @returns Object indicating if this is a conflict and if it's external
-   */
-  private isPortConflict(error: any): { isConflict: boolean; isExternal: boolean } {
-    if (error.code !== 'EADDRINUSE') {
-      return { isConflict: false, isExternal: false };
-    }
-    
-    // Check if we already have this port
-    const isBoundInternally = this.servers.has(Number(error.port));
-    return { isConflict: true, isExternal: !isBoundInternally };
-  }
-}