441 lines
14 KiB
TypeScript
441 lines
14 KiB
TypeScript
import * as plugins from '../../plugins.js';
|
|
import type { IDomainConfig, ISmartProxyOptions } from './models/interfaces.js';
|
|
import type { TForwardingType, IForwardConfig } from '../../forwarding/config/forwarding-types.js';
|
|
import type { ForwardingHandler } from '../../forwarding/handlers/base-handler.js';
|
|
import { ForwardingHandlerFactory } from '../../forwarding/factory/forwarding-factory.js';
|
|
import type { IRouteConfig } from './models/route-types.js';
|
|
import { RouteManager } from './route-manager.js';
|
|
|
|
/**
|
|
* Manages domain configurations and target selection
|
|
*/
|
|
export class DomainConfigManager {
|
|
// Track round-robin indices for domain configs
|
|
private domainTargetIndices: Map<IDomainConfig, number> = new Map();
|
|
|
|
// Cache forwarding handlers for each domain config
|
|
private forwardingHandlers: Map<IDomainConfig, ForwardingHandler> = new Map();
|
|
|
|
// Store derived domain configs from routes
|
|
private derivedDomainConfigs: IDomainConfig[] = [];
|
|
|
|
// Reference to RouteManager for route-based configuration
|
|
private routeManager?: RouteManager;
|
|
|
|
constructor(private settings: ISmartProxyOptions) {
|
|
// Initialize with derived domain configs if using route-based configuration
|
|
if (settings.routes && !settings.domainConfigs) {
|
|
this.generateDomainConfigsFromRoutes();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set the route manager reference for route-based queries
|
|
*/
|
|
public setRouteManager(routeManager: RouteManager): void {
|
|
this.routeManager = routeManager;
|
|
|
|
// Regenerate domain configs from routes if needed
|
|
if (this.settings.routes && (!this.settings.domainConfigs || this.settings.domainConfigs.length === 0)) {
|
|
this.generateDomainConfigsFromRoutes();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generate domain configs from routes
|
|
*/
|
|
public generateDomainConfigsFromRoutes(): void {
|
|
this.derivedDomainConfigs = [];
|
|
|
|
if (!this.settings.routes) return;
|
|
|
|
for (const route of this.settings.routes) {
|
|
if (route.action.type !== 'forward' || !route.match.domains) continue;
|
|
|
|
// Convert route to domain config
|
|
const domainConfig = this.routeToDomainConfig(route);
|
|
if (domainConfig) {
|
|
this.derivedDomainConfigs.push(domainConfig);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Convert a route to a domain config
|
|
*/
|
|
private routeToDomainConfig(route: IRouteConfig): IDomainConfig | null {
|
|
if (route.action.type !== 'forward' || !route.action.target) return null;
|
|
|
|
// Get domains from route
|
|
const domains = Array.isArray(route.match.domains) ?
|
|
route.match.domains :
|
|
(route.match.domains ? [route.match.domains] : []);
|
|
|
|
if (domains.length === 0) return null;
|
|
|
|
// Determine forwarding type based on TLS mode
|
|
let forwardingType: TForwardingType = 'http-only';
|
|
if (route.action.tls) {
|
|
switch (route.action.tls.mode) {
|
|
case 'passthrough':
|
|
forwardingType = 'https-passthrough';
|
|
break;
|
|
case 'terminate':
|
|
forwardingType = 'https-terminate-to-http';
|
|
break;
|
|
case 'terminate-and-reencrypt':
|
|
forwardingType = 'https-terminate-to-https';
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Create domain config
|
|
return {
|
|
domains,
|
|
forwarding: {
|
|
type: forwardingType,
|
|
target: {
|
|
host: route.action.target.host,
|
|
port: route.action.target.port
|
|
},
|
|
security: route.action.security ? {
|
|
allowedIps: route.action.security.allowedIps,
|
|
blockedIps: route.action.security.blockedIps,
|
|
maxConnections: route.action.security.maxConnections
|
|
} : undefined,
|
|
https: route.action.tls && route.action.tls.certificate !== 'auto' ? {
|
|
customCert: route.action.tls.certificate
|
|
} : undefined,
|
|
advanced: route.action.advanced
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Updates the domain configurations
|
|
*/
|
|
public updateDomainConfigs(newDomainConfigs: IDomainConfig[]): void {
|
|
// If we're using domainConfigs property, update it
|
|
if (this.settings.domainConfigs) {
|
|
this.settings.domainConfigs = newDomainConfigs;
|
|
} else {
|
|
// Otherwise update our derived configs
|
|
this.derivedDomainConfigs = newDomainConfigs;
|
|
}
|
|
|
|
// Reset target indices for removed configs
|
|
const currentConfigSet = new Set(newDomainConfigs);
|
|
for (const [config] of this.domainTargetIndices) {
|
|
if (!currentConfigSet.has(config)) {
|
|
this.domainTargetIndices.delete(config);
|
|
}
|
|
}
|
|
|
|
// Clear handlers for removed configs and create handlers for new configs
|
|
const handlersToRemove: IDomainConfig[] = [];
|
|
for (const [config] of this.forwardingHandlers) {
|
|
if (!currentConfigSet.has(config)) {
|
|
handlersToRemove.push(config);
|
|
}
|
|
}
|
|
|
|
// Remove handlers that are no longer needed
|
|
for (const config of handlersToRemove) {
|
|
this.forwardingHandlers.delete(config);
|
|
}
|
|
|
|
// Create handlers for new configs
|
|
for (const config of newDomainConfigs) {
|
|
if (!this.forwardingHandlers.has(config)) {
|
|
try {
|
|
const handler = this.createForwardingHandler(config);
|
|
this.forwardingHandlers.set(config, handler);
|
|
} catch (err) {
|
|
console.log(`Error creating forwarding handler for domain ${config.domains.join(', ')}: ${err}`);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get all domain configurations
|
|
*/
|
|
public getDomainConfigs(): IDomainConfig[] {
|
|
// Use domainConfigs from settings if available, otherwise use derived configs
|
|
return this.settings.domainConfigs || this.derivedDomainConfigs;
|
|
}
|
|
|
|
/**
|
|
* Find domain config matching a server name
|
|
*/
|
|
public findDomainConfig(serverName: string): IDomainConfig | undefined {
|
|
if (!serverName) return undefined;
|
|
|
|
// Get domain configs from the appropriate source
|
|
const domainConfigs = this.getDomainConfigs();
|
|
|
|
// Check for direct match
|
|
for (const config of domainConfigs) {
|
|
if (config.domains.some(d => plugins.minimatch(serverName, d))) {
|
|
return config;
|
|
}
|
|
}
|
|
|
|
// No match found
|
|
return undefined;
|
|
}
|
|
|
|
/**
|
|
* Find domain config for a specific port
|
|
*/
|
|
public findDomainConfigForPort(port: number): IDomainConfig | undefined {
|
|
// Get domain configs from the appropriate source
|
|
const domainConfigs = this.getDomainConfigs();
|
|
|
|
// Check if any domain config has a matching port range
|
|
for (const domain of domainConfigs) {
|
|
const portRanges = domain.forwarding?.advanced?.portRanges;
|
|
if (portRanges && portRanges.length > 0 && this.isPortInRanges(port, portRanges)) {
|
|
return domain;
|
|
}
|
|
}
|
|
|
|
// If we're in route-based mode, also check routes for this port
|
|
if (this.settings.routes && (!this.settings.domainConfigs || this.settings.domainConfigs.length === 0)) {
|
|
const routesForPort = this.settings.routes.filter(route => {
|
|
// Check if this port is in the route's ports
|
|
if (typeof route.match.ports === 'number') {
|
|
return route.match.ports === port;
|
|
} else if (Array.isArray(route.match.ports)) {
|
|
return route.match.ports.some(p => {
|
|
if (typeof p === 'number') {
|
|
return p === port;
|
|
} else if (p.from && p.to) {
|
|
return port >= p.from && port <= p.to;
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
return false;
|
|
});
|
|
|
|
// If we found any routes for this port, convert the first one to a domain config
|
|
if (routesForPort.length > 0 && routesForPort[0].action.type === 'forward') {
|
|
const domainConfig = this.routeToDomainConfig(routesForPort[0]);
|
|
if (domainConfig) {
|
|
return domainConfig;
|
|
}
|
|
}
|
|
}
|
|
|
|
return undefined;
|
|
}
|
|
|
|
/**
|
|
* Check if a port is within any of the given ranges
|
|
*/
|
|
public isPortInRanges(port: number, ranges: Array<{ from: number; to: number }>): boolean {
|
|
return ranges.some((range) => port >= range.from && port <= range.to);
|
|
}
|
|
|
|
/**
|
|
* Get target IP with round-robin support
|
|
*/
|
|
public getTargetIP(domainConfig: IDomainConfig): string {
|
|
const targetHosts = Array.isArray(domainConfig.forwarding.target.host)
|
|
? domainConfig.forwarding.target.host
|
|
: [domainConfig.forwarding.target.host];
|
|
|
|
if (targetHosts.length > 0) {
|
|
const currentIndex = this.domainTargetIndices.get(domainConfig) || 0;
|
|
const ip = targetHosts[currentIndex % targetHosts.length];
|
|
this.domainTargetIndices.set(domainConfig, currentIndex + 1);
|
|
return ip;
|
|
}
|
|
|
|
return this.settings.targetIP || 'localhost';
|
|
}
|
|
|
|
/**
|
|
* Get target host with round-robin support (for tests)
|
|
* This is just an alias for getTargetIP for easier test compatibility
|
|
*/
|
|
public getTargetHost(domainConfig: IDomainConfig): string {
|
|
return this.getTargetIP(domainConfig);
|
|
}
|
|
|
|
/**
|
|
* Get target port from domain config
|
|
*/
|
|
public getTargetPort(domainConfig: IDomainConfig, defaultPort: number): number {
|
|
return domainConfig.forwarding.target.port || defaultPort;
|
|
}
|
|
|
|
/**
|
|
* Checks if a domain should use NetworkProxy
|
|
*/
|
|
public shouldUseNetworkProxy(domainConfig: IDomainConfig): boolean {
|
|
const forwardingType = this.getForwardingType(domainConfig);
|
|
return forwardingType === 'https-terminate-to-http' ||
|
|
forwardingType === 'https-terminate-to-https';
|
|
}
|
|
|
|
/**
|
|
* Gets the NetworkProxy port for a domain
|
|
*/
|
|
public getNetworkProxyPort(domainConfig: IDomainConfig): number | undefined {
|
|
// First check if we should use NetworkProxy at all
|
|
if (!this.shouldUseNetworkProxy(domainConfig)) {
|
|
return undefined;
|
|
}
|
|
|
|
return domainConfig.forwarding.advanced?.networkProxyPort || this.settings.networkProxyPort;
|
|
}
|
|
|
|
/**
|
|
* Get effective allowed and blocked IPs for a domain
|
|
*
|
|
* This method combines domain-specific security rules from the forwarding configuration
|
|
* with global security defaults when necessary.
|
|
*/
|
|
public getEffectiveIPRules(domainConfig: IDomainConfig): {
|
|
allowedIPs: string[],
|
|
blockedIPs: string[]
|
|
} {
|
|
// Start with empty arrays
|
|
const allowedIPs: string[] = [];
|
|
const blockedIPs: string[] = [];
|
|
|
|
// Add IPs from forwarding security settings if available
|
|
if (domainConfig.forwarding?.security?.allowedIps) {
|
|
allowedIPs.push(...domainConfig.forwarding.security.allowedIps);
|
|
} else {
|
|
// If no allowed IPs are specified in forwarding config and global defaults exist, use them
|
|
if (this.settings.defaultAllowedIPs && this.settings.defaultAllowedIPs.length > 0) {
|
|
allowedIPs.push(...this.settings.defaultAllowedIPs);
|
|
} else {
|
|
// Default to allow all if no specific rules
|
|
allowedIPs.push('*');
|
|
}
|
|
}
|
|
|
|
// Add blocked IPs from forwarding security settings if available
|
|
if (domainConfig.forwarding?.security?.blockedIps) {
|
|
blockedIPs.push(...domainConfig.forwarding.security.blockedIps);
|
|
}
|
|
|
|
// Always add global blocked IPs, even if domain has its own rules
|
|
// This ensures that global blocks take precedence
|
|
if (this.settings.defaultBlockedIPs && this.settings.defaultBlockedIPs.length > 0) {
|
|
// Add only unique IPs that aren't already in the list
|
|
for (const ip of this.settings.defaultBlockedIPs) {
|
|
if (!blockedIPs.includes(ip)) {
|
|
blockedIPs.push(ip);
|
|
}
|
|
}
|
|
}
|
|
|
|
return {
|
|
allowedIPs,
|
|
blockedIPs
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Get connection timeout for a domain
|
|
*/
|
|
public getConnectionTimeout(domainConfig?: IDomainConfig): number {
|
|
if (domainConfig?.forwarding.advanced?.timeout) {
|
|
return domainConfig.forwarding.advanced.timeout;
|
|
}
|
|
|
|
return this.settings.maxConnectionLifetime || 86400000; // 24 hours default
|
|
}
|
|
|
|
/**
|
|
* Creates a forwarding handler for a domain configuration
|
|
*/
|
|
private createForwardingHandler(domainConfig: IDomainConfig): ForwardingHandler {
|
|
// Create a new handler using the factory
|
|
const handler = ForwardingHandlerFactory.createHandler(domainConfig.forwarding);
|
|
|
|
// Initialize the handler
|
|
handler.initialize().catch(err => {
|
|
console.log(`Error initializing forwarding handler for ${domainConfig.domains.join(', ')}: ${err}`);
|
|
});
|
|
|
|
return handler;
|
|
}
|
|
|
|
/**
|
|
* Gets a forwarding handler for a domain config
|
|
* If no handler exists, creates one
|
|
*/
|
|
public getForwardingHandler(domainConfig: IDomainConfig): ForwardingHandler {
|
|
// If we already have a handler, return it
|
|
if (this.forwardingHandlers.has(domainConfig)) {
|
|
return this.forwardingHandlers.get(domainConfig)!;
|
|
}
|
|
|
|
// Otherwise create a new handler
|
|
const handler = this.createForwardingHandler(domainConfig);
|
|
this.forwardingHandlers.set(domainConfig, handler);
|
|
|
|
return handler;
|
|
}
|
|
|
|
/**
|
|
* Gets the forwarding type for a domain config
|
|
*/
|
|
public getForwardingType(domainConfig?: IDomainConfig): TForwardingType | undefined {
|
|
if (!domainConfig?.forwarding) return undefined;
|
|
return domainConfig.forwarding.type;
|
|
}
|
|
|
|
/**
|
|
* Checks if the forwarding type requires TLS termination
|
|
*/
|
|
public requiresTlsTermination(domainConfig?: IDomainConfig): boolean {
|
|
if (!domainConfig) return false;
|
|
|
|
const forwardingType = this.getForwardingType(domainConfig);
|
|
return forwardingType === 'https-terminate-to-http' ||
|
|
forwardingType === 'https-terminate-to-https';
|
|
}
|
|
|
|
/**
|
|
* Checks if the forwarding type supports HTTP
|
|
*/
|
|
public supportsHttp(domainConfig?: IDomainConfig): boolean {
|
|
if (!domainConfig) return false;
|
|
|
|
const forwardingType = this.getForwardingType(domainConfig);
|
|
|
|
// HTTP-only always supports HTTP
|
|
if (forwardingType === 'http-only') return true;
|
|
|
|
// For termination types, check the HTTP settings
|
|
if (forwardingType === 'https-terminate-to-http' ||
|
|
forwardingType === 'https-terminate-to-https') {
|
|
// HTTP is supported by default for termination types
|
|
return domainConfig.forwarding?.http?.enabled !== false;
|
|
}
|
|
|
|
// HTTPS-passthrough doesn't support HTTP
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Checks if HTTP requests should be redirected to HTTPS
|
|
*/
|
|
public shouldRedirectToHttps(domainConfig?: IDomainConfig): boolean {
|
|
if (!domainConfig?.forwarding) return false;
|
|
|
|
// Only check for redirect if HTTP is enabled
|
|
if (this.supportsHttp(domainConfig)) {
|
|
return !!domainConfig.forwarding.http?.redirectToHttps;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
} |