@push.rocks/smartproxy 13.1.2 → 15.0.0

package/dist_ts/proxies/smart-proxy/route-connection-handler.js

@@ -0,0 +1,804 @@
+import * as plugins from '../../plugins.js';
+import { isRoutedOptions, isLegacyOptions } from './models/interfaces.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';
+/**
+ * Handles new connection processing and setup logic with support for route-based configuration
+ */
+export class RouteConnectionHandler {
+    constructor(settings, connectionManager, securityManager, domainConfigManager, tlsManager, networkProxyBridge, timeoutManager, routeManager) {
+        this.connectionManager = connectionManager;
+        this.securityManager = securityManager;
+        this.domainConfigManager = domainConfigManager;
+        this.tlsManager = tlsManager;
+        this.networkProxyBridge = networkProxyBridge;
+        this.timeoutManager = timeoutManager;
+        this.routeManager = routeManager;
+        this.settings = settings;
+    }
+    /**
+     * Handle a new incoming connection
+     */
+    handleConnection(socket) {
+        const remoteIP = socket.remoteAddress || '';
+        const localPort = socket.localPort || 0;
+        // Validate IP against rate limits and connection limits
+        const ipValidation = this.securityManager.validateIP(remoteIP);
+        if (!ipValidation.allowed) {
+            console.log(`Connection rejected from ${remoteIP}: ${ipValidation.reason}`);
+            socket.end();
+            socket.destroy();
+            return;
+        }
+        // Create a new connection record
+        const record = this.connectionManager.createConnection(socket);
+        const connectionId = record.id;
+        // Apply socket optimizations
+        socket.setNoDelay(this.settings.noDelay);
+        // Apply keep-alive settings if enabled
+        if (this.settings.keepAlive) {
+            socket.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.setKeepAliveProbes(10);
+                    }
+                    if ('setKeepAliveInterval' in socket) {
+                        socket.setKeepAliveInterval(1000);
+                    }
+                }
+                catch (err) {
+                    // Ignore errors - these are optional enhancements
+                    if (this.settings.enableDetailedLogging) {
+                        console.log(`[${connectionId}] Enhanced TCP keep-alive settings not supported: ${err}`);
+                    }
+                }
+            }
+        }
+        if (this.settings.enableDetailedLogging) {
+            console.log(`[${connectionId}] New connection from ${remoteIP} on port ${localPort}. ` +
+                `Keep-Alive: ${record.hasKeepAlive ? 'Enabled' : 'Disabled'}. ` +
+                `Active connections: ${this.connectionManager.getConnectionCount()}`);
+        }
+        else {
+            console.log(`New connection from ${remoteIP} on port ${localPort}. Active connections: ${this.connectionManager.getConnectionCount()}`);
+        }
+        // Start TLS SNI handling
+        this.handleTlsConnection(socket, record);
+    }
+    /**
+     * Handle a connection and wait for TLS handshake for SNI extraction if needed
+     */
+    handleTlsConnection(socket, record) {
+        const connectionId = record.id;
+        const localPort = record.localPort;
+        let initialDataReceived = false;
+        // Set an initial timeout for handshake data
+        let initialTimeout = setTimeout(() => {
+            if (!initialDataReceived) {
+                console.log(`[${connectionId}] Initial data warning (${this.settings.initialDataTimeout}ms) for connection from ${record.remoteIP}`);
+                // Add a grace period
+                setTimeout(() => {
+                    if (!initialDataReceived) {
+                        console.log(`[${connectionId}] Final initial data timeout after grace period`);
+                        if (record.incomingTerminationReason === null) {
+                            record.incomingTerminationReason = 'initial_timeout';
+                            this.connectionManager.incrementTerminationStat('incoming', 'initial_timeout');
+                        }
+                        socket.end();
+                        this.connectionManager.cleanupConnection(record, 'initial_timeout');
+                    }
+                }, 30000);
+            }
+        }, this.settings.initialDataTimeout);
+        // Make sure timeout doesn't keep the process alive
+        if (initialTimeout.unref) {
+            initialTimeout.unref();
+        }
+        // Set up error handler
+        socket.on('error', this.connectionManager.handleError('incoming', record));
+        // First data handler to capture initial TLS handshake
+        socket.once('data', (chunk) => {
+            // Clear the initial timeout since we've received data
+            if (initialTimeout) {
+                clearTimeout(initialTimeout);
+                initialTimeout = null;
+            }
+            initialDataReceived = true;
+            record.hasReceivedInitialData = true;
+            // Block non-TLS connections on port 443
+            if (!this.tlsManager.isTlsHandshake(chunk) && localPort === 443) {
+                console.log(`[${connectionId}] Non-TLS connection detected on port 443. ` +
+                    `Terminating connection - only TLS traffic is allowed on standard HTTPS port.`);
+                if (record.incomingTerminationReason === null) {
+                    record.incomingTerminationReason = 'non_tls_blocked';
+                    this.connectionManager.incrementTerminationStat('incoming', 'non_tls_blocked');
+                }
+                socket.end();
+                this.connectionManager.cleanupConnection(record, 'non_tls_blocked');
+                return;
+            }
+            // Check if this looks like a TLS handshake
+            let serverName = '';
+            if (this.tlsManager.isTlsHandshake(chunk)) {
+                record.isTLS = true;
+                // Check for ClientHello to extract SNI
+                if (this.tlsManager.isClientHello(chunk)) {
+                    // Create connection info for SNI extraction
+                    const connInfo = {
+                        sourceIp: record.remoteIP,
+                        sourcePort: socket.remotePort || 0,
+                        destIp: socket.localAddress || '',
+                        destPort: socket.localPort || 0,
+                    };
+                    // Extract SNI
+                    serverName = this.tlsManager.extractSNI(chunk, connInfo) || '';
+                    // Lock the connection to the negotiated SNI
+                    record.lockedDomain = serverName;
+                    // Check if we should reject connections without SNI
+                    if (!serverName && this.settings.allowSessionTicket === false) {
+                        console.log(`[${connectionId}] No SNI detected in TLS ClientHello; sending TLS alert.`);
+                        if (record.incomingTerminationReason === null) {
+                            record.incomingTerminationReason = 'session_ticket_blocked_no_sni';
+                            this.connectionManager.incrementTerminationStat('incoming', 'session_ticket_blocked_no_sni');
+                        }
+                        const alert = Buffer.from([0x15, 0x03, 0x03, 0x00, 0x02, 0x01, 0x70]);
+                        try {
+                            socket.cork();
+                            socket.write(alert);
+                            socket.uncork();
+                            socket.end();
+                        }
+                        catch {
+                            socket.end();
+                        }
+                        this.connectionManager.cleanupConnection(record, 'session_ticket_blocked_no_sni');
+                        return;
+                    }
+                    if (this.settings.enableDetailedLogging) {
+                        console.log(`[${connectionId}] TLS connection with SNI: ${serverName || '(empty)'}`);
+                    }
+                }
+            }
+            // Find the appropriate route for this connection
+            this.routeConnection(socket, record, serverName, chunk);
+        });
+    }
+    /**
+     * Route the connection based on match criteria
+     */
+    routeConnection(socket, record, serverName, initialChunk) {
+        const connectionId = record.id;
+        const localPort = record.localPort;
+        const remoteIP = record.remoteIP;
+        // Find matching route
+        const routeMatch = this.routeManager.findMatchingRoute({
+            port: localPort,
+            domain: serverName,
+            clientIp: remoteIP,
+            path: undefined, // We don't have path info at this point
+            tlsVersion: undefined // We don't extract TLS version yet
+        });
+        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
+            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) {
+                    const isAllowed = this.securityManager.isIPAuthorized(remoteIP, defaultSecuritySettings.allowedIPs, defaultSecuritySettings.blockedIPs || []);
+                    if (!isAllowed) {
+                        console.log(`[${connectionId}] IP ${remoteIP} not in default allowed list`);
+                        socket.end();
+                        this.connectionManager.cleanupConnection(record, 'ip_blocked');
+                        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;
+            let targetPort;
+            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 {
+                // Fall back to legacy settings
+                targetHost = this.settings.targetIP || 'localhost';
+                targetPort = this.settings.toPort;
+            }
+            return this.setupDirectConnection(socket, record, undefined, serverName, initialChunk, undefined, targetHost, targetPort);
+        }
+        // A matching route was found
+        const route = routeMatch.route;
+        if (this.settings.enableDetailedLogging) {
+            console.log(`[${connectionId}] Route matched: "${route.name || 'unnamed'}" for ${serverName || 'connection'} on port ${localPort}`);
+        }
+        // Handle the route based on its action type
+        switch (route.action.type) {
+            case 'forward':
+                return this.handleForwardAction(socket, record, route, initialChunk);
+            case 'redirect':
+                return this.handleRedirectAction(socket, record, route);
+            case 'block':
+                return this.handleBlockAction(socket, record, route);
+            default:
+                console.log(`[${connectionId}] Unknown action type: ${route.action.type}`);
+                socket.end();
+                this.connectionManager.cleanupConnection(record, 'unknown_action');
+        }
+    }
+    /**
+     * Handle a forward action for a route
+     */
+    handleForwardAction(socket, record, route, initialChunk) {
+        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`);
+            socket.end();
+            this.connectionManager.cleanupConnection(record, 'missing_target');
+            return;
+        }
+        // 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}`);
+                    }
+                    // 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, undefined, record.lockedDomain, initialChunk, undefined, targetHost, targetPort);
+                case 'terminate':
+                case 'terminate-and-reencrypt':
+                    // For TLS termination, use NetworkProxy
+                    if (this.networkProxyBridge.getNetworkProxy()) {
+                        if (this.settings.enableDetailedLogging) {
+                            console.log(`[${connectionId}] Using NetworkProxy for TLS termination to ${action.target.host}`);
+                        }
+                        // If we have an initial chunk with TLS data, start processing it
+                        if (initialChunk && record.isTLS) {
+                            return this.networkProxyBridge.forwardToNetworkProxy(connectionId, socket, record, initialChunk, this.settings.networkProxyPort, (reason) => this.connectionManager.initiateCleanupOnce(record, reason));
+                        }
+                        // This shouldn't normally happen - we should have TLS data at this point
+                        console.log(`[${connectionId}] TLS termination route without TLS data`);
+                        socket.end();
+                        this.connectionManager.cleanupConnection(record, 'tls_error');
+                        return;
+                    }
+                    else {
+                        console.log(`[${connectionId}] NetworkProxy not available for TLS termination`);
+                        socket.end();
+                        this.connectionManager.cleanupConnection(record, 'no_network_proxy');
+                        return;
+                    }
+            }
+        }
+        else {
+            // No TLS settings - basic forwarding
+            if (this.settings.enableDetailedLogging) {
+                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;
+            return this.setupDirectConnection(socket, record, undefined, record.lockedDomain, initialChunk, undefined, targetHost, targetPort);
+        }
+    }
+    /**
+     * Handle a redirect action for a route
+     */
+    handleRedirectAction(socket, record, route) {
+        const connectionId = record.id;
+        const action = route.action;
+        // We should have a redirect configuration
+        if (!action.redirect) {
+            console.log(`[${connectionId}] Redirect action missing redirect configuration`);
+            socket.end();
+            this.connectionManager.cleanupConnection(record, 'missing_redirect');
+            return;
+        }
+        // For TLS connections, we can't do redirects at the TCP level
+        if (record.isTLS) {
+            console.log(`[${connectionId}] Cannot redirect TLS connection at TCP level`);
+            socket.end();
+            this.connectionManager.cleanupConnection(record, 'tls_redirect_error');
+            return;
+        }
+        // Wait for the first HTTP request to perform the redirect
+        const dataListeners = [];
+        const httpDataHandler = (chunk) => {
+            // Remove all data listeners to avoid duplicated processing
+            for (const listener of dataListeners) {
+                socket.removeListener('data', listener);
+            }
+            // Parse HTTP request to get path
+            try {
+                const headersEnd = chunk.indexOf('\r\n\r\n');
+                if (headersEnd === -1) {
+                    // Not a complete HTTP request, need more data
+                    socket.once('data', httpDataHandler);
+                    dataListeners.push(httpDataHandler);
+                    return;
+                }
+                const httpHeaders = chunk.slice(0, headersEnd).toString();
+                const requestLine = httpHeaders.split('\r\n')[0];
+                const [method, path] = requestLine.split(' ');
+                // Extract Host header
+                const hostMatch = httpHeaders.match(/Host: (.+?)(\r\n|\r|\n|$)/i);
+                const host = hostMatch ? hostMatch[1].trim() : record.lockedDomain || '';
+                // Process the redirect URL with template variables
+                let redirectUrl = action.redirect.to;
+                redirectUrl = redirectUrl.replace(/\{domain\}/g, host);
+                redirectUrl = redirectUrl.replace(/\{path\}/g, path || '');
+                redirectUrl = redirectUrl.replace(/\{port\}/g, record.localPort.toString());
+                // Prepare the HTTP redirect response
+                const redirectResponse = [
+                    `HTTP/1.1 ${action.redirect.status} Moved`,
+                    `Location: ${redirectUrl}`,
+                    'Connection: close',
+                    'Content-Length: 0',
+                    '',
+                    ''
+                ].join('\r\n');
+                if (this.settings.enableDetailedLogging) {
+                    console.log(`[${connectionId}] Redirecting to ${redirectUrl} with status ${action.redirect.status}`);
+                }
+                // Send the redirect response
+                socket.end(redirectResponse);
+                this.connectionManager.initiateCleanupOnce(record, 'redirect_complete');
+            }
+            catch (err) {
+                console.log(`[${connectionId}] Error processing HTTP redirect: ${err}`);
+                socket.end();
+                this.connectionManager.initiateCleanupOnce(record, 'redirect_error');
+            }
+        };
+        // Setup the HTTP data handler
+        socket.once('data', httpDataHandler);
+        dataListeners.push(httpDataHandler);
+    }
+    /**
+     * Handle a block action for a route
+     */
+    handleBlockAction(socket, record, route) {
+        const connectionId = record.id;
+        if (this.settings.enableDetailedLogging) {
+            console.log(`[${connectionId}] Blocking connection based on route "${route.name || 'unnamed'}"`);
+        }
+        // Simply close the connection
+        socket.end();
+        this.connectionManager.initiateCleanupOnce(record, 'route_blocked');
+    }
+    /**
+     * Handle a connection using legacy domain configuration
+     */
+    handleLegacyConnection(socket, record, serverName, domainConfig, initialChunk) {
+        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
+     */
+    setupDirectConnection(socket, record, domainConfig, serverName, initialChunk, overridePort, targetHost, targetPort) {
+        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);
+        // 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);
+        // Setup connection options
+        const connectionOptions = {
+            host: finalTargetHost,
+            port: finalTargetPort,
+        };
+        // Preserve source IP if configured
+        if (this.settings.defaults?.preserveSourceIP || this.settings.preserveSourceIP) {
+            connectionOptions.localAddress = record.remoteIP.replace('::ffff:', '');
+        }
+        // Create a safe queue for incoming data
+        const dataQueue = [];
+        let queueSize = 0;
+        let processingQueue = false;
+        let drainPending = false;
+        let pipingEstablished = false;
+        // Pause the incoming socket to prevent buffer overflows
+        socket.pause();
+        // Function to safely process the data queue without losing events
+        const processDataQueue = () => {
+            if (processingQueue || dataQueue.length === 0 || pipingEstablished)
+                return;
+            processingQueue = true;
+            try {
+                // Process all queued chunks with the current active handler
+                while (dataQueue.length > 0) {
+                    const chunk = dataQueue.shift();
+                    queueSize -= chunk.length;
+                    // Once piping is established, we shouldn't get here,
+                    // but just in case, pass to the outgoing socket directly
+                    if (pipingEstablished && record.outgoing) {
+                        record.outgoing.write(chunk);
+                        continue;
+                    }
+                    // Track bytes received
+                    record.bytesReceived += chunk.length;
+                    // Check for TLS handshake
+                    if (!record.isTLS && this.tlsManager.isTlsHandshake(chunk)) {
+                        record.isTLS = true;
+                        if (this.settings.enableTlsDebugLogging) {
+                            console.log(`[${connectionId}] TLS handshake detected in tempDataHandler, ${chunk.length} bytes`);
+                        }
+                    }
+                    // Check if adding this chunk would exceed the buffer limit
+                    const newSize = record.pendingDataSize + chunk.length;
+                    if (this.settings.maxPendingDataSize && newSize > this.settings.maxPendingDataSize) {
+                        console.log(`[${connectionId}] Buffer limit exceeded for connection from ${record.remoteIP}: ${newSize} bytes > ${this.settings.maxPendingDataSize} bytes`);
+                        socket.end(); // Gracefully close the socket
+                        this.connectionManager.initiateCleanupOnce(record, 'buffer_limit_exceeded');
+                        return;
+                    }
+                    // Buffer the chunk and update the size counter
+                    record.pendingData.push(Buffer.from(chunk));
+                    record.pendingDataSize = newSize;
+                    this.timeoutManager.updateActivity(record);
+                }
+            }
+            finally {
+                processingQueue = false;
+                // If there's a pending drain and we've processed everything,
+                // signal we're ready for more data if we haven't established piping yet
+                if (drainPending && dataQueue.length === 0 && !pipingEstablished) {
+                    drainPending = false;
+                    socket.resume();
+                }
+            }
+        };
+        // Unified data handler that safely queues incoming data
+        const safeDataHandler = (chunk) => {
+            // If piping is already established, just let the pipe handle it
+            if (pipingEstablished)
+                return;
+            // Add to our queue for orderly processing
+            dataQueue.push(Buffer.from(chunk)); // Make a copy to be safe
+            queueSize += chunk.length;
+            // If queue is getting large, pause socket until we catch up
+            if (this.settings.maxPendingDataSize && queueSize > this.settings.maxPendingDataSize * 0.8) {
+                socket.pause();
+                drainPending = true;
+            }
+            // Process the queue
+            processDataQueue();
+        };
+        // Add our safe data handler
+        socket.on('data', safeDataHandler);
+        // Add initial chunk to pending data if present
+        if (initialChunk) {
+            record.bytesReceived += initialChunk.length;
+            record.pendingData.push(Buffer.from(initialChunk));
+            record.pendingDataSize = initialChunk.length;
+        }
+        // Create the target socket but don't set up piping immediately
+        const targetSocket = plugins.net.connect(connectionOptions);
+        record.outgoing = targetSocket;
+        record.outgoingStartTime = Date.now();
+        // Apply socket optimizations
+        targetSocket.setNoDelay(this.settings.noDelay);
+        // Apply keep-alive settings to the outgoing connection as well
+        if (this.settings.keepAlive) {
+            targetSocket.setKeepAlive(true, this.settings.keepAliveInitialDelay);
+            // Apply enhanced TCP keep-alive options if enabled
+            if (this.settings.enableKeepAliveProbes) {
+                try {
+                    if ('setKeepAliveProbes' in targetSocket) {
+                        targetSocket.setKeepAliveProbes(10);
+                    }
+                    if ('setKeepAliveInterval' in targetSocket) {
+                        targetSocket.setKeepAliveInterval(1000);
+                    }
+                }
+                catch (err) {
+                    // Ignore errors - these are optional enhancements
+                    if (this.settings.enableDetailedLogging) {
+                        console.log(`[${connectionId}] Enhanced TCP keep-alive not supported for outgoing socket: ${err}`);
+                    }
+                }
+            }
+        }
+        // Setup specific error handler for connection phase
+        targetSocket.once('error', (err) => {
+            // This handler runs only once during the initial connection phase
+            const code = err.code;
+            console.log(`[${connectionId}] Connection setup error to ${finalTargetHost}:${connectionOptions.port}: ${err.message} (${code})`);
+            // Resume the incoming socket to prevent it from hanging
+            socket.resume();
+            if (code === 'ECONNREFUSED') {
+                console.log(`[${connectionId}] Target ${finalTargetHost}:${connectionOptions.port} refused connection`);
+            }
+            else if (code === 'ETIMEDOUT') {
+                console.log(`[${connectionId}] Connection to ${finalTargetHost}:${connectionOptions.port} timed out`);
+            }
+            else if (code === 'ECONNRESET') {
+                console.log(`[${connectionId}] Connection to ${finalTargetHost}:${connectionOptions.port} was reset`);
+            }
+            else if (code === 'EHOSTUNREACH') {
+                console.log(`[${connectionId}] Host ${finalTargetHost} is unreachable`);
+            }
+            // Clear any existing error handler after connection phase
+            targetSocket.removeAllListeners('error');
+            // Re-add the normal error handler for established connections
+            targetSocket.on('error', this.connectionManager.handleError('outgoing', record));
+            if (record.outgoingTerminationReason === null) {
+                record.outgoingTerminationReason = 'connection_failed';
+                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}`);
+                }
+            }
+            // Clean up the connection
+            this.connectionManager.initiateCleanupOnce(record, `connection_failed_${code}`);
+        });
+        // Setup close handler
+        targetSocket.on('close', this.connectionManager.handleClose('outgoing', record));
+        socket.on('close', this.connectionManager.handleClose('incoming', record));
+        // Handle timeouts with keep-alive awareness
+        socket.on('timeout', () => {
+            // For keep-alive connections, just log a warning instead of closing
+            if (record.hasKeepAlive) {
+                console.log(`[${connectionId}] Timeout event on incoming keep-alive connection from ${record.remoteIP} after ${plugins.prettyMs(this.settings.socketTimeout || 3600000)}. Connection preserved.`);
+                return;
+            }
+            // For non-keep-alive connections, proceed with normal cleanup
+            console.log(`[${connectionId}] Timeout on incoming side from ${record.remoteIP} after ${plugins.prettyMs(this.settings.socketTimeout || 3600000)}`);
+            if (record.incomingTerminationReason === null) {
+                record.incomingTerminationReason = 'timeout';
+                this.connectionManager.incrementTerminationStat('incoming', 'timeout');
+            }
+            this.connectionManager.initiateCleanupOnce(record, 'timeout_incoming');
+        });
+        targetSocket.on('timeout', () => {
+            // For keep-alive connections, just log a warning instead of closing
+            if (record.hasKeepAlive) {
+                console.log(`[${connectionId}] Timeout event on outgoing keep-alive connection from ${record.remoteIP} after ${plugins.prettyMs(this.settings.socketTimeout || 3600000)}. Connection preserved.`);
+                return;
+            }
+            // For non-keep-alive connections, proceed with normal cleanup
+            console.log(`[${connectionId}] Timeout on outgoing side from ${record.remoteIP} after ${plugins.prettyMs(this.settings.socketTimeout || 3600000)}`);
+            if (record.outgoingTerminationReason === null) {
+                record.outgoingTerminationReason = 'timeout';
+                this.connectionManager.incrementTerminationStat('outgoing', 'timeout');
+            }
+            this.connectionManager.initiateCleanupOnce(record, 'timeout_outgoing');
+        });
+        // Apply socket timeouts
+        this.timeoutManager.applySocketTimeouts(record);
+        // Track outgoing data for bytes counting
+        targetSocket.on('data', (chunk) => {
+            record.bytesSent += chunk.length;
+            this.timeoutManager.updateActivity(record);
+        });
+        // Wait for the outgoing connection to be ready before setting up piping
+        targetSocket.once('connect', () => {
+            // Clear the initial connection error handler
+            targetSocket.removeAllListeners('error');
+            // Add the normal error handler for established connections
+            targetSocket.on('error', this.connectionManager.handleError('outgoing', record));
+            // Process any remaining data in the queue before switching to piping
+            processDataQueue();
+            // Set up piping immediately
+            pipingEstablished = true;
+            // Flush all pending data to target
+            if (record.pendingData.length > 0) {
+                const combinedData = Buffer.concat(record.pendingData);
+                if (this.settings.enableDetailedLogging) {
+                    console.log(`[${connectionId}] Forwarding ${combinedData.length} bytes of initial data to target`);
+                }
+                // Write pending data immediately
+                targetSocket.write(combinedData, (err) => {
+                    if (err) {
+                        console.log(`[${connectionId}] Error writing pending data to target: ${err.message}`);
+                        return this.connectionManager.initiateCleanupOnce(record, 'write_error');
+                    }
+                });
+                // Clear the buffer now that we've processed it
+                record.pendingData = [];
+                record.pendingDataSize = 0;
+            }
+            // Setup piping in both directions without any delays
+            socket.pipe(targetSocket);
+            targetSocket.pipe(socket);
+            // Resume the socket to ensure data flows
+            socket.resume();
+            // Process any data that might be queued in the interim
+            if (dataQueue.length > 0) {
+                // Write any remaining queued data directly to the target socket
+                for (const chunk of dataQueue) {
+                    targetSocket.write(chunk);
+                }
+                // Clear the queue
+                dataQueue.length = 0;
+                queueSize = 0;
+            }
+            if (this.settings.enableDetailedLogging) {
+                console.log(`[${connectionId}] Connection established: ${record.remoteIP} -> ${finalTargetHost}:${connectionOptions.port}` +
+                    `${serverName
+                        ? ` (SNI: ${serverName})`
+                        : domainConfig
+                            ? ` (Port-based for domain: ${domainConfig.domains.join(', ')})`
+                            : ''}` +
+                    ` TLS: ${record.isTLS ? 'Yes' : 'No'}, Keep-Alive: ${record.hasKeepAlive ? 'Yes' : 'No'}`);
+            }
+            else {
+                console.log(`Connection established: ${record.remoteIP} -> ${finalTargetHost}:${connectionOptions.port}` +
+                    `${serverName
+                        ? ` (SNI: ${serverName})`
+                        : domainConfig
+                            ? ` (Port-based for domain: ${domainConfig.domains.join(', ')})`
+                            : ''}`);
+            }
+            // Add the renegotiation handler for SNI validation
+            if (serverName) {
+                // Create connection info object for the existing connection
+                const connInfo = {
+                    sourceIp: record.remoteIP,
+                    sourcePort: record.incoming.remotePort || 0,
+                    destIp: record.incoming.localAddress || '',
+                    destPort: record.incoming.localPort || 0,
+                };
+                // Create a renegotiation handler function
+                const renegotiationHandler = this.tlsManager.createRenegotiationHandler(connectionId, serverName, connInfo, (connectionId, reason) => this.connectionManager.initiateCleanupOnce(record, reason));
+                // Store the handler in the connection record so we can remove it during cleanup
+                record.renegotiationHandler = renegotiationHandler;
+                // Add the handler to the socket
+                socket.on('data', renegotiationHandler);
+                if (this.settings.enableDetailedLogging) {
+                    console.log(`[${connectionId}] TLS renegotiation handler installed for SNI domain: ${serverName}`);
+                    if (this.settings.allowSessionTicket === false) {
+                        console.log(`[${connectionId}] Session ticket usage is disabled. Connection will be reset on reconnection attempts.`);
+                    }
+                }
+            }
+            // Set connection timeout
+            record.cleanupTimer = this.timeoutManager.setupConnectionTimeout(record, (record, reason) => {
+                console.log(`[${connectionId}] Connection from ${record.remoteIP} exceeded max lifetime, forcing cleanup.`);
+                this.connectionManager.initiateCleanupOnce(record, reason);
+            });
+            // Mark TLS handshake as complete for TLS connections
+            if (record.isTLS) {
+                record.tlsHandshakeComplete = true;
+                if (this.settings.enableTlsDebugLogging) {
+                    console.log(`[${connectionId}] TLS handshake complete for connection from ${record.remoteIP}`);
+                }
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route-connection-handler.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/route-connection-handler.ts"],"names":[],"mappings":"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"}