@serve.zone/dcrouter 2.12.4

package/dist_ts/mail/delivery/smtpserver/connection-manager.js

@@ -0,0 +1,894 @@
+/**
+ * SMTP Connection Manager
+ * Responsible for managing socket connections to the SMTP server
+ */
+import * as plugins from '../../../plugins.js';
+import { SmtpResponseCode, SMTP_DEFAULTS, SmtpState } from './constants.js';
+import { SmtpLogger } from './utils/logging.js';
+import { adaptiveLogger } from './utils/adaptive-logging.js';
+import { getSocketDetails, formatMultilineResponse } from './utils/helpers.js';
+/**
+ * Manager for SMTP connections
+ * Handles connection setup, event listeners, and lifecycle management
+ * Provides resource management, connection tracking, and monitoring
+ */
+export class ConnectionManager {
+    /**
+     * Creates a new connection manager with enhanced resource management
+     * @param smtpServer - SMTP server instance
+     */
+    constructor(smtpServer) {
+        /**
+         * Set of active socket connections
+         */
+        this.activeConnections = new Set();
+        /**
+         * Connection tracking for resource management
+         */
+        this.connectionStats = {
+            totalConnections: 0,
+            activeConnections: 0,
+            peakConnections: 0,
+            rejectedConnections: 0,
+            closedConnections: 0,
+            erroredConnections: 0,
+            timedOutConnections: 0
+        };
+        /**
+         * Per-IP connection tracking for rate limiting
+         */
+        this.ipConnections = new Map();
+        /**
+         * Resource monitoring interval
+         */
+        this.resourceCheckInterval = null;
+        /**
+         * Track cleanup timers so we can clear them
+         */
+        this.cleanupTimers = new Set();
+        this.smtpServer = smtpServer;
+        // Get options from server
+        const serverOptions = this.smtpServer.getOptions();
+        // Default values for resource management - adjusted for production scalability
+        const DEFAULT_MAX_CONNECTIONS_PER_IP = 50; // Increased to support high-concurrency scenarios
+        const DEFAULT_CONNECTION_RATE_LIMIT = 200; // Increased for production load handling
+        const DEFAULT_CONNECTION_RATE_WINDOW = 60 * 1000; // 60 seconds window
+        const DEFAULT_BUFFER_SIZE_LIMIT = 10 * 1024 * 1024; // 10 MB
+        const DEFAULT_RESOURCE_CHECK_INTERVAL = 30 * 1000; // 30 seconds
+        this.options = {
+            hostname: serverOptions.hostname || SMTP_DEFAULTS.HOSTNAME,
+            maxConnections: serverOptions.maxConnections || SMTP_DEFAULTS.MAX_CONNECTIONS,
+            socketTimeout: serverOptions.socketTimeout || SMTP_DEFAULTS.SOCKET_TIMEOUT,
+            maxConnectionsPerIP: DEFAULT_MAX_CONNECTIONS_PER_IP,
+            connectionRateLimit: DEFAULT_CONNECTION_RATE_LIMIT,
+            connectionRateWindow: DEFAULT_CONNECTION_RATE_WINDOW,
+            bufferSizeLimit: DEFAULT_BUFFER_SIZE_LIMIT,
+            resourceCheckInterval: DEFAULT_RESOURCE_CHECK_INTERVAL
+        };
+        // Start resource monitoring
+        this.startResourceMonitoring();
+    }
+    /**
+     * Start resource monitoring interval to check resource usage
+     */
+    startResourceMonitoring() {
+        // Clear any existing interval
+        if (this.resourceCheckInterval) {
+            clearInterval(this.resourceCheckInterval);
+        }
+        // Set up new interval
+        this.resourceCheckInterval = setInterval(() => {
+            this.monitorResourceUsage();
+        }, this.options.resourceCheckInterval);
+    }
+    /**
+     * Monitor resource usage and log statistics
+     */
+    monitorResourceUsage() {
+        // Calculate memory usage
+        const memoryUsage = process.memoryUsage();
+        const memoryUsageMB = {
+            rss: Math.round(memoryUsage.rss / 1024 / 1024),
+            heapTotal: Math.round(memoryUsage.heapTotal / 1024 / 1024),
+            heapUsed: Math.round(memoryUsage.heapUsed / 1024 / 1024),
+            external: Math.round(memoryUsage.external / 1024 / 1024)
+        };
+        // Calculate connection rate metrics
+        const activeIPs = Array.from(this.ipConnections.entries())
+            .filter(([_, data]) => data.count > 0).length;
+        const highVolumeIPs = Array.from(this.ipConnections.entries())
+            .filter(([_, data]) => data.count > this.options.connectionRateLimit / 2).length;
+        // Log resource usage with more detailed metrics
+        SmtpLogger.info('Resource usage stats', {
+            connections: {
+                active: this.activeConnections.size,
+                total: this.connectionStats.totalConnections,
+                peak: this.connectionStats.peakConnections,
+                rejected: this.connectionStats.rejectedConnections,
+                closed: this.connectionStats.closedConnections,
+                errored: this.connectionStats.erroredConnections,
+                timedOut: this.connectionStats.timedOutConnections
+            },
+            memory: memoryUsageMB,
+            ipTracking: {
+                uniqueIPs: this.ipConnections.size,
+                activeIPs: activeIPs,
+                highVolumeIPs: highVolumeIPs
+            },
+            resourceLimits: {
+                maxConnections: this.options.maxConnections,
+                maxConnectionsPerIP: this.options.maxConnectionsPerIP,
+                connectionRateLimit: this.options.connectionRateLimit,
+                bufferSizeLimit: Math.round(this.options.bufferSizeLimit / 1024 / 1024) + 'MB'
+            }
+        });
+        // Check for potential DoS conditions
+        if (highVolumeIPs > 3) {
+            SmtpLogger.warn(`Potential DoS detected: ${highVolumeIPs} IPs with high connection rates`);
+        }
+        // Assess memory usage trends
+        if (memoryUsageMB.heapUsed > 500) { // Over 500MB heap used
+            SmtpLogger.warn(`High memory usage detected: ${memoryUsageMB.heapUsed}MB heap used`);
+        }
+        // Clean up expired IP rate limits and validate resource tracking
+        this.cleanupIpRateLimits();
+    }
+    /**
+     * Clean up expired IP rate limits and perform additional resource monitoring
+     */
+    cleanupIpRateLimits() {
+        const now = Date.now();
+        const windowThreshold = now - this.options.connectionRateWindow;
+        let activeIps = 0;
+        let removedEntries = 0;
+        // Iterate through IP connections and manage entries
+        for (const [ip, data] of this.ipConnections.entries()) {
+            // If the last connection was before the window threshold + one extra window, remove the entry
+            if (data.lastConnection < windowThreshold - this.options.connectionRateWindow) {
+                // Remove stale entries to prevent memory growth
+                this.ipConnections.delete(ip);
+                removedEntries++;
+            }
+            // If last connection was before the window threshold, reset the count
+            else if (data.lastConnection < windowThreshold) {
+                if (data.count > 0) {
+                    // Reset but keep the IP in the map with a zero count
+                    this.ipConnections.set(ip, {
+                        count: 0,
+                        firstConnection: now,
+                        lastConnection: now
+                    });
+                }
+            }
+            else {
+                // This IP is still active within the current window
+                activeIps++;
+            }
+        }
+        // Log cleanup activity if significant changes occurred
+        if (removedEntries > 0) {
+            SmtpLogger.debug(`IP rate limit cleanup: removed ${removedEntries} stale entries, ${this.ipConnections.size} remaining, ${activeIps} active in current window`);
+        }
+        // Check for memory leaks in connection tracking
+        if (this.activeConnections.size > 0 && this.connectionStats.activeConnections !== this.activeConnections.size) {
+            SmtpLogger.warn(`Connection tracking inconsistency detected: stats.active=${this.connectionStats.activeConnections}, actual=${this.activeConnections.size}`);
+            // Fix the inconsistency
+            this.connectionStats.activeConnections = this.activeConnections.size;
+        }
+        // Validate and clean leaked resources if needed
+        this.validateResourceTracking();
+    }
+    /**
+     * Validate and repair resource tracking to prevent leaks
+     */
+    validateResourceTracking() {
+        // Prepare a detailed report if inconsistencies are found
+        const inconsistenciesFound = [];
+        // 1. Check active connections count matches activeConnections set size
+        if (this.connectionStats.activeConnections !== this.activeConnections.size) {
+            inconsistenciesFound.push({
+                issue: 'Active connection count mismatch',
+                stats: this.connectionStats.activeConnections,
+                actual: this.activeConnections.size,
+                action: 'Auto-corrected'
+            });
+            this.connectionStats.activeConnections = this.activeConnections.size;
+        }
+        // 2. Check for destroyed sockets in active connections
+        let destroyedSocketsCount = 0;
+        for (const socket of this.activeConnections) {
+            if (socket.destroyed) {
+                destroyedSocketsCount++;
+                // This should not happen - remove destroyed sockets from tracking
+                this.activeConnections.delete(socket);
+            }
+        }
+        if (destroyedSocketsCount > 0) {
+            inconsistenciesFound.push({
+                issue: 'Destroyed sockets in active list',
+                count: destroyedSocketsCount,
+                action: 'Removed from tracking'
+            });
+            // Update active connections count after cleanup
+            this.connectionStats.activeConnections = this.activeConnections.size;
+        }
+        // 3. Check for sessions without corresponding active connections
+        const sessionCount = this.smtpServer.getSessionManager().getSessionCount();
+        if (sessionCount > this.activeConnections.size) {
+            inconsistenciesFound.push({
+                issue: 'Orphaned sessions',
+                sessions: sessionCount,
+                connections: this.activeConnections.size,
+                action: 'Session cleanup recommended'
+            });
+        }
+        // If any inconsistencies found, log a detailed report
+        if (inconsistenciesFound.length > 0) {
+            SmtpLogger.warn('Resource tracking inconsistencies detected and repaired', { inconsistencies: inconsistenciesFound });
+        }
+    }
+    /**
+     * Handle a new connection with resource management
+     * @param socket - Client socket
+     */
+    async handleNewConnection(socket) {
+        // Update connection stats
+        this.connectionStats.totalConnections++;
+        this.connectionStats.activeConnections = this.activeConnections.size + 1;
+        if (this.connectionStats.activeConnections > this.connectionStats.peakConnections) {
+            this.connectionStats.peakConnections = this.connectionStats.activeConnections;
+        }
+        // Get client IP
+        const remoteAddress = socket.remoteAddress || '0.0.0.0';
+        // Use UnifiedRateLimiter for connection rate limiting
+        const emailServer = this.smtpServer.getEmailServer();
+        const rateLimiter = emailServer.getRateLimiter();
+        // Check connection limit with UnifiedRateLimiter
+        const connectionResult = rateLimiter.recordConnection(remoteAddress);
+        if (!connectionResult.allowed) {
+            this.rejectConnection(socket, connectionResult.reason || 'Rate limit exceeded');
+            this.connectionStats.rejectedConnections++;
+            return;
+        }
+        // Still track IP connections locally for cleanup purposes
+        this.trackIPConnection(remoteAddress);
+        // Check if maximum global connections reached
+        if (this.hasReachedMaxConnections()) {
+            this.rejectConnection(socket, 'Too many connections');
+            this.connectionStats.rejectedConnections++;
+            return;
+        }
+        // Add socket to active connections
+        this.activeConnections.add(socket);
+        // Set up socket options
+        socket.setKeepAlive(true);
+        socket.setTimeout(this.options.socketTimeout);
+        // Explicitly set socket buffer sizes to prevent memory issues
+        socket.setNoDelay(true); // Disable Nagle's algorithm for better responsiveness
+        // Set limits on socket buffer size if supported by Node.js version
+        try {
+            // Here we set reasonable buffer limits to prevent memory exhaustion attacks
+            const highWaterMark = 64 * 1024; // 64 KB
+            // Note: Socket high water mark methods can't be set directly in newer Node.js versions
+            // These would need to be set during socket creation or with a different API
+        }
+        catch (error) {
+            // Ignore errors from older Node.js versions that don't support these methods
+            SmtpLogger.debug(`Could not set socket buffer limits: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // Track this IP connection
+        this.trackIPConnection(remoteAddress);
+        // Set up event handlers
+        this.setupSocketEventHandlers(socket);
+        // Create a session for this connection
+        this.smtpServer.getSessionManager().createSession(socket, false);
+        // Log the new connection using adaptive logger
+        const socketDetails = getSocketDetails(socket);
+        adaptiveLogger.logConnection(socket, 'connect');
+        // Update adaptive logger with current connection count
+        adaptiveLogger.updateConnectionCount(this.connectionStats.activeConnections);
+        // Send greeting
+        this.sendGreeting(socket);
+    }
+    /**
+     * Check if an IP has exceeded the rate limit
+     * @param ip - Client IP address
+     * @returns True if rate limited
+     */
+    isIPRateLimited(ip) {
+        const now = Date.now();
+        const ipData = this.ipConnections.get(ip);
+        if (!ipData) {
+            return false; // No previous connections
+        }
+        // Check if we're within the rate window
+        const isWithinWindow = now - ipData.firstConnection <= this.options.connectionRateWindow;
+        // If within window and count exceeds limit, rate limit is applied
+        if (isWithinWindow && ipData.count >= this.options.connectionRateLimit) {
+            SmtpLogger.warn(`Rate limit exceeded for IP ${ip}: ${ipData.count} connections in ${Math.round((now - ipData.firstConnection) / 1000)}s`);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Track a new connection from an IP
+     * @param ip - Client IP address
+     */
+    trackIPConnection(ip) {
+        const now = Date.now();
+        const ipData = this.ipConnections.get(ip);
+        if (!ipData) {
+            // First connection from this IP
+            this.ipConnections.set(ip, {
+                count: 1,
+                firstConnection: now,
+                lastConnection: now
+            });
+        }
+        else {
+            // Check if we need to reset the window
+            if (now - ipData.lastConnection > this.options.connectionRateWindow) {
+                // Reset the window
+                this.ipConnections.set(ip, {
+                    count: 1,
+                    firstConnection: now,
+                    lastConnection: now
+                });
+            }
+            else {
+                // Increment within the current window
+                this.ipConnections.set(ip, {
+                    count: ipData.count + 1,
+                    firstConnection: ipData.firstConnection,
+                    lastConnection: now
+                });
+            }
+        }
+    }
+    /**
+     * Check if an IP has reached its connection limit
+     * @param ip - Client IP address
+     * @returns True if limit reached
+     */
+    hasReachedIPConnectionLimit(ip) {
+        let ipConnectionCount = 0;
+        // Count active connections from this IP
+        for (const socket of this.activeConnections) {
+            if (socket.remoteAddress === ip) {
+                ipConnectionCount++;
+            }
+        }
+        return ipConnectionCount >= this.options.maxConnectionsPerIP;
+    }
+    /**
+     * Handle a new secure TLS connection with resource management
+     * @param socket - Client TLS socket
+     */
+    async handleNewSecureConnection(socket) {
+        // Update connection stats
+        this.connectionStats.totalConnections++;
+        this.connectionStats.activeConnections = this.activeConnections.size + 1;
+        if (this.connectionStats.activeConnections > this.connectionStats.peakConnections) {
+            this.connectionStats.peakConnections = this.connectionStats.activeConnections;
+        }
+        // Get client IP
+        const remoteAddress = socket.remoteAddress || '0.0.0.0';
+        // Use UnifiedRateLimiter for connection rate limiting
+        const emailServer = this.smtpServer.getEmailServer();
+        const rateLimiter = emailServer.getRateLimiter();
+        // Check connection limit with UnifiedRateLimiter
+        const connectionResult = rateLimiter.recordConnection(remoteAddress);
+        if (!connectionResult.allowed) {
+            this.rejectConnection(socket, connectionResult.reason || 'Rate limit exceeded');
+            this.connectionStats.rejectedConnections++;
+            return;
+        }
+        // Still track IP connections locally for cleanup purposes
+        this.trackIPConnection(remoteAddress);
+        // Check if maximum global connections reached
+        if (this.hasReachedMaxConnections()) {
+            this.rejectConnection(socket, 'Too many connections');
+            this.connectionStats.rejectedConnections++;
+            return;
+        }
+        // Add socket to active connections
+        this.activeConnections.add(socket);
+        // Set up socket options
+        socket.setKeepAlive(true);
+        socket.setTimeout(this.options.socketTimeout);
+        // Explicitly set socket buffer sizes to prevent memory issues
+        socket.setNoDelay(true); // Disable Nagle's algorithm for better responsiveness
+        // Set limits on socket buffer size if supported by Node.js version
+        try {
+            // Here we set reasonable buffer limits to prevent memory exhaustion attacks
+            const highWaterMark = 64 * 1024; // 64 KB
+            // Note: Socket high water mark methods can't be set directly in newer Node.js versions
+            // These would need to be set during socket creation or with a different API
+        }
+        catch (error) {
+            // Ignore errors from older Node.js versions that don't support these methods
+            SmtpLogger.debug(`Could not set socket buffer limits: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // Track this IP connection
+        this.trackIPConnection(remoteAddress);
+        // Set up event handlers
+        this.setupSocketEventHandlers(socket);
+        // Create a session for this connection
+        this.smtpServer.getSessionManager().createSession(socket, true);
+        // Log the new secure connection using adaptive logger
+        adaptiveLogger.logConnection(socket, 'connect');
+        // Update adaptive logger with current connection count
+        adaptiveLogger.updateConnectionCount(this.connectionStats.activeConnections);
+        // Send greeting
+        this.sendGreeting(socket);
+    }
+    /**
+     * Set up event handlers for a socket with enhanced resource management
+     * @param socket - Client socket
+     */
+    setupSocketEventHandlers(socket) {
+        // Store existing socket event handlers before adding new ones
+        const existingDataHandler = socket.listeners('data')[0];
+        const existingCloseHandler = socket.listeners('close')[0];
+        const existingErrorHandler = socket.listeners('error')[0];
+        const existingTimeoutHandler = socket.listeners('timeout')[0];
+        // Remove existing event handlers if they exist
+        if (existingDataHandler)
+            socket.removeListener('data', existingDataHandler);
+        if (existingCloseHandler)
+            socket.removeListener('close', existingCloseHandler);
+        if (existingErrorHandler)
+            socket.removeListener('error', existingErrorHandler);
+        if (existingTimeoutHandler)
+            socket.removeListener('timeout', existingTimeoutHandler);
+        // Data event - process incoming data from the client with resource limits
+        let buffer = '';
+        let totalBytesReceived = 0;
+        socket.on('data', async (data) => {
+            try {
+                // Get current session and update activity timestamp
+                const session = this.smtpServer.getSessionManager().getSession(socket);
+                if (session) {
+                    this.smtpServer.getSessionManager().updateSessionActivity(session);
+                }
+                // Check if we're in DATA receiving mode - handle differently
+                if (session && session.state === SmtpState.DATA_RECEIVING) {
+                    // In DATA mode, pass raw chunks directly to command handler with special marker
+                    // Don't line-buffer large email content
+                    try {
+                        const dataString = data.toString('utf8');
+                        // Use a special prefix to indicate this is raw data, not a command line
+                        // CRITICAL FIX: Must await to prevent async pile-up
+                        await this.smtpServer.getCommandHandler().processCommand(socket, `__RAW_DATA__${dataString}`);
+                        return;
+                    }
+                    catch (dataError) {
+                        SmtpLogger.error(`Data handler error during DATA mode: ${dataError instanceof Error ? dataError.message : String(dataError)}`);
+                        socket.destroy();
+                        return;
+                    }
+                }
+                // For command mode, continue with line-buffered processing
+                // Check buffer size limits to prevent memory attacks
+                totalBytesReceived += data.length;
+                if (buffer.length > this.options.bufferSizeLimit) {
+                    // Buffer is too large, reject the connection
+                    SmtpLogger.warn(`Buffer size limit exceeded: ${buffer.length} bytes for ${socket.remoteAddress}`);
+                    this.sendResponse(socket, `${SmtpResponseCode.EXCEEDED_STORAGE} Message too large, disconnecting`);
+                    socket.destroy();
+                    return;
+                }
+                // Impose a total transfer limit to prevent DoS
+                if (totalBytesReceived > this.options.bufferSizeLimit * 2) {
+                    SmtpLogger.warn(`Total transfer limit exceeded: ${totalBytesReceived} bytes for ${socket.remoteAddress}`);
+                    this.sendResponse(socket, `${SmtpResponseCode.EXCEEDED_STORAGE} Transfer limit exceeded, disconnecting`);
+                    socket.destroy();
+                    return;
+                }
+                // Convert buffer to string safely with explicit encoding
+                const dataString = data.toString('utf8');
+                // Buffer incoming data
+                buffer += dataString;
+                // Process complete lines
+                let lineEndPos;
+                while ((lineEndPos = buffer.indexOf(SMTP_DEFAULTS.CRLF)) !== -1) {
+                    // Extract a complete line
+                    const line = buffer.substring(0, lineEndPos);
+                    buffer = buffer.substring(lineEndPos + 2); // +2 to skip CRLF
+                    // Check line length to prevent extremely long lines
+                    if (line.length > 4096) { // 4KB line limit is reasonable for SMTP
+                        SmtpLogger.warn(`Line length limit exceeded: ${line.length} bytes for ${socket.remoteAddress}`);
+                        this.sendResponse(socket, `${SmtpResponseCode.SYNTAX_ERROR} Line too long, disconnecting`);
+                        socket.destroy();
+                        return;
+                    }
+                    // Process non-empty lines
+                    if (line.length > 0) {
+                        try {
+                            // CRITICAL FIX: Must await processCommand to prevent async pile-up
+                            // This was causing the busy loop with high CPU usage when many empty lines were processed
+                            await this.smtpServer.getCommandHandler().processCommand(socket, line);
+                        }
+                        catch (error) {
+                            // Handle any errors in command processing
+                            SmtpLogger.error(`Command handler error: ${error instanceof Error ? error.message : String(error)}`);
+                            this.sendResponse(socket, `${SmtpResponseCode.LOCAL_ERROR} Internal server error`);
+                            // If there's a severe error, close the connection
+                            if (error instanceof Error &&
+                                (error.message.includes('fatal') || error.message.includes('critical'))) {
+                                socket.destroy();
+                                return;
+                            }
+                        }
+                    }
+                }
+                // If buffer is getting too large without CRLF, it might be a DoS attempt
+                if (buffer.length > 10240) { // 10KB is a reasonable limit for a line without CRLF
+                    SmtpLogger.warn(`Incomplete line too large: ${buffer.length} bytes for ${socket.remoteAddress}`);
+                    this.sendResponse(socket, `${SmtpResponseCode.SYNTAX_ERROR} Incomplete line too large, disconnecting`);
+                    socket.destroy();
+                }
+            }
+            catch (error) {
+                // Handle any unexpected errors during data processing
+                SmtpLogger.error(`Data handler error: ${error instanceof Error ? error.message : String(error)}`);
+                socket.destroy();
+            }
+        });
+        // Add drain event handler to manage flow control
+        socket.on('drain', () => {
+            // Socket buffer has been emptied, resume data flow if needed
+            if (socket.isPaused()) {
+                socket.resume();
+                SmtpLogger.debug(`Resumed socket for ${socket.remoteAddress} after drain`);
+            }
+        });
+        // Close event - clean up when connection is closed
+        socket.on('close', (hadError) => {
+            this.handleSocketClose(socket, hadError);
+        });
+        // Error event - handle socket errors
+        socket.on('error', (err) => {
+            this.handleSocketError(socket, err);
+        });
+        // Timeout event - handle socket timeouts
+        socket.on('timeout', () => {
+            this.handleSocketTimeout(socket);
+        });
+    }
+    /**
+     * Get the current connection count
+     * @returns Number of active connections
+     */
+    getConnectionCount() {
+        return this.activeConnections.size;
+    }
+    /**
+     * Check if the server has reached the maximum number of connections
+     * @returns True if max connections reached
+     */
+    hasReachedMaxConnections() {
+        return this.activeConnections.size >= this.options.maxConnections;
+    }
+    /**
+     * Close all active connections
+     */
+    closeAllConnections() {
+        const connectionCount = this.activeConnections.size;
+        if (connectionCount === 0) {
+            return;
+        }
+        SmtpLogger.info(`Closing all connections (count: ${connectionCount})`);
+        for (const socket of this.activeConnections) {
+            try {
+                // Send service closing notification
+                this.sendServiceClosing(socket);
+                // End the socket gracefully
+                socket.end();
+                // Force destroy after a short delay if not already destroyed
+                const destroyTimer = setTimeout(() => {
+                    if (!socket.destroyed) {
+                        socket.destroy();
+                    }
+                    this.cleanupTimers.delete(destroyTimer);
+                }, 100);
+                this.cleanupTimers.add(destroyTimer);
+            }
+            catch (error) {
+                SmtpLogger.error(`Error closing connection: ${error instanceof Error ? error.message : String(error)}`);
+                // Force destroy on error
+                try {
+                    socket.destroy();
+                }
+                catch (e) {
+                    // Ignore destroy errors
+                }
+            }
+        }
+        // Clear active connections
+        this.activeConnections.clear();
+        // Stop resource monitoring to prevent hanging timers
+        if (this.resourceCheckInterval) {
+            clearInterval(this.resourceCheckInterval);
+            this.resourceCheckInterval = null;
+        }
+    }
+    /**
+     * Handle socket close event
+     * @param socket - Client socket
+     * @param hadError - Whether the socket was closed due to error
+     */
+    handleSocketClose(socket, hadError) {
+        try {
+            // Update connection statistics
+            this.connectionStats.closedConnections++;
+            this.connectionStats.activeConnections = this.activeConnections.size - 1;
+            // Get socket details for logging
+            const socketDetails = getSocketDetails(socket);
+            const socketId = `${socketDetails.remoteAddress}:${socketDetails.remotePort}`;
+            // Log with appropriate level based on whether there was an error
+            if (hadError) {
+                SmtpLogger.warn(`Socket closed with error: ${socketId}`);
+            }
+            else {
+                SmtpLogger.debug(`Socket closed normally: ${socketId}`);
+            }
+            // Get the session before removing it
+            const session = this.smtpServer.getSessionManager().getSession(socket);
+            // Remove from active connections
+            this.activeConnections.delete(socket);
+            // Remove from session manager
+            this.smtpServer.getSessionManager().removeSession(socket);
+            // Cancel any timeout ID stored in the session
+            if (session?.dataTimeoutId) {
+                clearTimeout(session.dataTimeoutId);
+            }
+            // Log connection close with session details if available
+            adaptiveLogger.logConnection(socket, 'close', session);
+            // Update adaptive logger with new connection count
+            adaptiveLogger.updateConnectionCount(this.connectionStats.activeConnections);
+        }
+        catch (error) {
+            // Handle any unexpected errors during cleanup
+            SmtpLogger.error(`Error in handleSocketClose: ${error instanceof Error ? error.message : String(error)}`);
+            // Ensure socket is removed from active connections even if an error occurs
+            this.activeConnections.delete(socket);
+        }
+    }
+    /**
+     * Handle socket error event
+     * @param socket - Client socket
+     * @param error - Error object
+     */
+    handleSocketError(socket, error) {
+        try {
+            // Update connection statistics
+            this.connectionStats.erroredConnections++;
+            // Get socket details for context
+            const socketDetails = getSocketDetails(socket);
+            const socketId = `${socketDetails.remoteAddress}:${socketDetails.remotePort}`;
+            // Get the session
+            const session = this.smtpServer.getSessionManager().getSession(socket);
+            // Detailed error logging with context information
+            SmtpLogger.error(`Socket error for ${socketId}: ${error.message}`, {
+                errorCode: error.code,
+                errorStack: error.stack,
+                sessionId: session?.id,
+                sessionState: session?.state,
+                remoteAddress: socketDetails.remoteAddress,
+                remotePort: socketDetails.remotePort
+            });
+            // Log the error for connection tracking using adaptive logger
+            adaptiveLogger.logConnection(socket, 'error', session, error);
+            // Cancel any timeout ID stored in the session
+            if (session?.dataTimeoutId) {
+                clearTimeout(session.dataTimeoutId);
+            }
+            // Close the socket if not already closed
+            if (!socket.destroyed) {
+                socket.destroy();
+            }
+            // Remove from active connections (cleanup after error)
+            this.activeConnections.delete(socket);
+            // Remove from session manager
+            this.smtpServer.getSessionManager().removeSession(socket);
+        }
+        catch (handlerError) {
+            // Meta-error handling (errors in the error handler)
+            SmtpLogger.error(`Error in handleSocketError: ${handlerError instanceof Error ? handlerError.message : String(handlerError)}`);
+            // Ensure socket is destroyed and removed from active connections
+            if (!socket.destroyed) {
+                socket.destroy();
+            }
+            this.activeConnections.delete(socket);
+        }
+    }
+    /**
+     * Handle socket timeout event
+     * @param socket - Client socket
+     */
+    handleSocketTimeout(socket) {
+        try {
+            // Update connection statistics
+            this.connectionStats.timedOutConnections++;
+            // Get socket details for context
+            const socketDetails = getSocketDetails(socket);
+            const socketId = `${socketDetails.remoteAddress}:${socketDetails.remotePort}`;
+            // Get the session
+            const session = this.smtpServer.getSessionManager().getSession(socket);
+            // Get timing information for better debugging
+            const now = Date.now();
+            const idleTime = session?.lastActivity ? now - session.lastActivity : 'unknown';
+            if (session) {
+                // Log the timeout with extended details
+                SmtpLogger.warn(`Socket timeout from ${session.remoteAddress}`, {
+                    sessionId: session.id,
+                    remoteAddress: session.remoteAddress,
+                    state: session.state,
+                    timeout: this.options.socketTimeout,
+                    idleTime: idleTime,
+                    emailState: session.envelope?.mailFrom ? 'has-sender' : 'no-sender',
+                    recipientCount: session.envelope?.rcptTo?.length || 0
+                });
+                // Cancel any timeout ID stored in the session
+                if (session.dataTimeoutId) {
+                    clearTimeout(session.dataTimeoutId);
+                }
+                // Send timeout notification to client
+                this.sendResponse(socket, `${SmtpResponseCode.SERVICE_NOT_AVAILABLE} Connection timeout - closing connection`);
+            }
+            else {
+                // Log timeout without session context
+                SmtpLogger.warn(`Socket timeout without session from ${socketId}`);
+            }
+            // Close the socket gracefully
+            try {
+                socket.end();
+                // Set a forced close timeout in case socket.end() doesn't close the connection
+                const timeoutDestroyTimer = setTimeout(() => {
+                    if (!socket.destroyed) {
+                        SmtpLogger.warn(`Forcing destroy of timed out socket: ${socketId}`);
+                        socket.destroy();
+                    }
+                    this.cleanupTimers.delete(timeoutDestroyTimer);
+                }, 5000); // 5 second grace period for socket to end properly
+                this.cleanupTimers.add(timeoutDestroyTimer);
+            }
+            catch (error) {
+                SmtpLogger.error(`Error ending timed out socket: ${error instanceof Error ? error.message : String(error)}`);
+                // Ensure socket is destroyed even if end() fails
+                if (!socket.destroyed) {
+                    socket.destroy();
+                }
+            }
+            // Clean up resources
+            this.activeConnections.delete(socket);
+            this.smtpServer.getSessionManager().removeSession(socket);
+        }
+        catch (handlerError) {
+            // Handle any unexpected errors during timeout handling
+            SmtpLogger.error(`Error in handleSocketTimeout: ${handlerError instanceof Error ? handlerError.message : String(handlerError)}`);
+            // Ensure socket is destroyed and removed from tracking
+            if (!socket.destroyed) {
+                socket.destroy();
+            }
+            this.activeConnections.delete(socket);
+        }
+    }
+    /**
+     * Reject a connection
+     * @param socket - Client socket
+     * @param reason - Reason for rejection
+     */
+    rejectConnection(socket, reason) {
+        // Log the rejection
+        const socketDetails = getSocketDetails(socket);
+        SmtpLogger.warn(`Connection rejected from ${socketDetails.remoteAddress}:${socketDetails.remotePort}: ${reason}`);
+        // Send rejection message
+        this.sendResponse(socket, `${SmtpResponseCode.SERVICE_NOT_AVAILABLE} ${this.options.hostname} Service temporarily unavailable - ${reason}`);
+        // Close the socket
+        try {
+            socket.end();
+        }
+        catch (error) {
+            SmtpLogger.error(`Error ending rejected socket: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Send greeting message
+     * @param socket - Client socket
+     */
+    sendGreeting(socket) {
+        const greeting = `${SmtpResponseCode.SERVICE_READY} ${this.options.hostname} ESMTP service ready`;
+        this.sendResponse(socket, greeting);
+    }
+    /**
+     * Send service closing notification
+     * @param socket - Client socket
+     */
+    sendServiceClosing(socket) {
+        const message = `${SmtpResponseCode.SERVICE_CLOSING} ${this.options.hostname} Service closing transmission channel`;
+        this.sendResponse(socket, message);
+    }
+    /**
+     * Send response to client
+     * @param socket - Client socket
+     * @param response - Response to send
+     */
+    sendResponse(socket, response) {
+        // Check if socket is still writable before attempting to write
+        if (socket.destroyed || socket.readyState !== 'open' || !socket.writable) {
+            SmtpLogger.debug(`Skipping response to closed/destroyed socket: ${response}`, {
+                remoteAddress: socket.remoteAddress,
+                remotePort: socket.remotePort,
+                destroyed: socket.destroyed,
+                readyState: socket.readyState,
+                writable: socket.writable
+            });
+            return;
+        }
+        try {
+            socket.write(`${response}${SMTP_DEFAULTS.CRLF}`);
+            adaptiveLogger.logResponse(response, socket);
+        }
+        catch (error) {
+            // Log error and destroy socket
+            SmtpLogger.error(`Error sending response: ${error instanceof Error ? error.message : String(error)}`, {
+                response,
+                remoteAddress: socket.remoteAddress,
+                remotePort: socket.remotePort,
+                error: error instanceof Error ? error : new Error(String(error))
+            });
+            socket.destroy();
+        }
+    }
+    /**
+     * Handle a new connection (interface requirement)
+     */
+    async handleConnection(socket, secure) {
+        if (secure) {
+            this.handleNewSecureConnection(socket);
+        }
+        else {
+            this.handleNewConnection(socket);
+        }
+    }
+    /**
+     * Check if accepting new connections (interface requirement)
+     */
+    canAcceptConnection() {
+        return !this.hasReachedMaxConnections();
+    }
+    /**
+     * Clean up resources
+     */
+    destroy() {
+        // Clear resource monitoring interval
+        if (this.resourceCheckInterval) {
+            clearInterval(this.resourceCheckInterval);
+            this.resourceCheckInterval = null;
+        }
+        // Clear all cleanup timers
+        for (const timer of this.cleanupTimers) {
+            clearTimeout(timer);
+        }
+        this.cleanupTimers.clear();
+        // Close all active connections
+        this.closeAllConnections();
+        // Clear maps
+        this.activeConnections.clear();
+        this.ipConnections.clear();
+        // Reset connection stats
+        this.connectionStats = {
+            totalConnections: 0,
+            activeConnections: 0,
+            peakConnections: 0,
+            rejectedConnections: 0,
+            closedConnections: 0,
+            erroredConnections: 0,
+            timedOutConnections: 0
+        };
+        SmtpLogger.debug('ConnectionManager destroyed');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connection-manager.js","sourceRoot":"","sources":["../../../../ts/mail/delivery/smtpserver/connection-manager.ts"],"names":[],"mappings":"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"}