@serve.zone/dcrouter 2.12.4

package/dist_ts/mail/delivery/smtpserver/smtp-server.js

@@ -0,0 +1,666 @@
+/**
+ * SMTP Server
+ * Core implementation for the refactored SMTP server
+ */
+import * as plugins from '../../../plugins.js';
+import { SmtpState } from './interfaces.js';
+import { SessionManager } from './session-manager.js';
+import { ConnectionManager } from './connection-manager.js';
+import { CommandHandler } from './command-handler.js';
+import { DataHandler } from './data-handler.js';
+import { TlsHandler } from './tls-handler.js';
+import { SecurityHandler } from './security-handler.js';
+import { SMTP_DEFAULTS } from './constants.js';
+import { mergeWithDefaults } from './utils/helpers.js';
+import { SmtpLogger } from './utils/logging.js';
+import { adaptiveLogger } from './utils/adaptive-logging.js';
+import { UnifiedEmailServer } from '../../routing/classes.unified.email.server.js';
+/**
+ * SMTP Server implementation
+ * The main server class that coordinates all components
+ */
+export class SmtpServer {
+    /**
+     * Creates a new SMTP server
+     * @param config - Server configuration
+     */
+    constructor(config) {
+        /**
+         * Net server instance
+         */
+        this.server = null;
+        /**
+         * Secure server instance
+         */
+        this.secureServer = null;
+        /**
+         * Whether the server is running
+         */
+        this.running = false;
+        /**
+         * Server recovery state
+         */
+        this.recoveryState = {
+            /**
+             * Whether recovery is in progress
+             */
+            recovering: false,
+            /**
+             * Number of consecutive connection failures
+             */
+            connectionFailures: 0,
+            /**
+             * Last recovery attempt timestamp
+             */
+            lastRecoveryAttempt: 0,
+            /**
+             * Recovery cooldown in milliseconds
+             */
+            recoveryCooldown: 5000,
+            /**
+             * Maximum recovery attempts before giving up
+             */
+            maxRecoveryAttempts: 3,
+            /**
+             * Current recovery attempt
+             */
+            currentRecoveryAttempt: 0
+        };
+        this.emailServer = config.emailServer;
+        this.options = mergeWithDefaults(config.options);
+        // Create components - all components now receive the SMTP server instance
+        this.sessionManager = config.sessionManager || new SessionManager({
+            socketTimeout: this.options.socketTimeout,
+            connectionTimeout: this.options.connectionTimeout,
+            cleanupInterval: this.options.cleanupInterval
+        });
+        this.securityHandler = config.securityHandler || new SecurityHandler(this);
+        this.tlsHandler = config.tlsHandler || new TlsHandler(this);
+        this.dataHandler = config.dataHandler || new DataHandler(this);
+        this.commandHandler = config.commandHandler || new CommandHandler(this);
+        this.connectionManager = config.connectionManager || new ConnectionManager(this);
+    }
+    /**
+     * Start the SMTP server
+     * @returns Promise that resolves when server is started
+     */
+    async listen() {
+        if (this.running) {
+            throw new Error('SMTP server is already running');
+        }
+        try {
+            // Create the server
+            this.server = plugins.net.createServer((socket) => {
+                // Check IP reputation before handling connection
+                this.securityHandler.checkIpReputation(socket)
+                    .then(allowed => {
+                    if (allowed) {
+                        this.connectionManager.handleNewConnection(socket);
+                    }
+                    else {
+                        // Close connection if IP is not allowed
+                        socket.destroy();
+                    }
+                })
+                    .catch(error => {
+                    SmtpLogger.error(`IP reputation check error: ${error instanceof Error ? error.message : String(error)}`, {
+                        remoteAddress: socket.remoteAddress,
+                        error: error instanceof Error ? error : new Error(String(error))
+                    });
+                    // Allow connection on error (fail open)
+                    this.connectionManager.handleNewConnection(socket);
+                });
+            });
+            // Set up error handling with recovery
+            this.server.on('error', (err) => {
+                SmtpLogger.error(`SMTP server error: ${err.message}`, { error: err });
+                // Try to recover from specific errors
+                if (this.shouldAttemptRecovery(err)) {
+                    this.attemptServerRecovery('standard', err);
+                }
+            });
+            // Start listening
+            await new Promise((resolve, reject) => {
+                if (!this.server) {
+                    reject(new Error('Server not initialized'));
+                    return;
+                }
+                this.server.listen(this.options.port, this.options.host, () => {
+                    SmtpLogger.info(`SMTP server listening on ${this.options.host || '0.0.0.0'}:${this.options.port}`);
+                    resolve();
+                });
+                this.server.on('error', reject);
+            });
+            // Start secure server if configured
+            if (this.options.securePort && this.tlsHandler.isTlsEnabled()) {
+                try {
+                    // Import the secure server creation utility from our new module
+                    // This gives us better certificate handling and error resilience
+                    const { createSecureTlsServer } = await import('./secure-server.js');
+                    // Create secure server with the certificates
+                    // This uses a more robust approach to certificate loading and validation
+                    this.secureServer = createSecureTlsServer({
+                        key: this.options.key,
+                        cert: this.options.cert,
+                        ca: this.options.ca
+                    });
+                    SmtpLogger.info(`Created secure TLS server for port ${this.options.securePort}`);
+                    if (this.secureServer) {
+                        // Use explicit error handling for secure connections
+                        this.secureServer.on('tlsClientError', (err, tlsSocket) => {
+                            SmtpLogger.error(`TLS client error: ${err.message}`, {
+                                error: err,
+                                remoteAddress: tlsSocket.remoteAddress,
+                                remotePort: tlsSocket.remotePort,
+                                stack: err.stack
+                            });
+                            // No need to destroy, the error event will handle that
+                        });
+                        // Register the secure connection handler
+                        this.secureServer.on('secureConnection', (socket) => {
+                            SmtpLogger.info(`New secure connection from ${socket.remoteAddress}:${socket.remotePort}`, {
+                                protocol: socket.getProtocol(),
+                                cipher: socket.getCipher()?.name
+                            });
+                            // Check IP reputation before handling connection
+                            this.securityHandler.checkIpReputation(socket)
+                                .then(allowed => {
+                                if (allowed) {
+                                    // Pass the connection to the connection manager
+                                    this.connectionManager.handleNewSecureConnection(socket);
+                                }
+                                else {
+                                    // Close connection if IP is not allowed
+                                    socket.destroy();
+                                }
+                            })
+                                .catch(error => {
+                                SmtpLogger.error(`IP reputation check error: ${error instanceof Error ? error.message : String(error)}`, {
+                                    remoteAddress: socket.remoteAddress,
+                                    error: error instanceof Error ? error : new Error(String(error)),
+                                    stack: error instanceof Error ? error.stack : 'No stack trace available'
+                                });
+                                // Allow connection on error (fail open)
+                                this.connectionManager.handleNewSecureConnection(socket);
+                            });
+                        });
+                        // Global error handler for the secure server with recovery
+                        this.secureServer.on('error', (err) => {
+                            SmtpLogger.error(`SMTP secure server error: ${err.message}`, {
+                                error: err,
+                                stack: err.stack
+                            });
+                            // Try to recover from specific errors
+                            if (this.shouldAttemptRecovery(err)) {
+                                this.attemptServerRecovery('secure', err);
+                            }
+                        });
+                        // Start listening on secure port
+                        await new Promise((resolve, reject) => {
+                            if (!this.secureServer) {
+                                reject(new Error('Secure server not initialized'));
+                                return;
+                            }
+                            this.secureServer.listen(this.options.securePort, this.options.host, () => {
+                                SmtpLogger.info(`SMTP secure server listening on ${this.options.host || '0.0.0.0'}:${this.options.securePort}`);
+                                resolve();
+                            });
+                            // Only use error event for startup issues
+                            this.secureServer.once('error', reject);
+                        });
+                    }
+                    else {
+                        SmtpLogger.warn('Failed to create secure server, TLS may not be properly configured');
+                    }
+                }
+                catch (error) {
+                    SmtpLogger.error(`Error setting up secure server: ${error instanceof Error ? error.message : String(error)}`, {
+                        error: error instanceof Error ? error : new Error(String(error)),
+                        stack: error instanceof Error ? error.stack : 'No stack trace available'
+                    });
+                }
+            }
+            this.running = true;
+        }
+        catch (error) {
+            SmtpLogger.error(`Failed to start SMTP server: ${error instanceof Error ? error.message : String(error)}`, {
+                error: error instanceof Error ? error : new Error(String(error))
+            });
+            // Clean up on error
+            this.close();
+            throw error;
+        }
+    }
+    /**
+     * Stop the SMTP server
+     * @returns Promise that resolves when server is stopped
+     */
+    async close() {
+        if (!this.running) {
+            return;
+        }
+        SmtpLogger.info('Stopping SMTP server');
+        try {
+            // Close all active connections
+            this.connectionManager.closeAllConnections();
+            // Clear all sessions
+            this.sessionManager.clearAllSessions();
+            // Clean up adaptive logger to prevent hanging timers
+            adaptiveLogger.destroy();
+            // Destroy all components to clean up their resources
+            await this.destroy();
+            // Close servers
+            const closePromises = [];
+            if (this.server) {
+                closePromises.push(new Promise((resolve, reject) => {
+                    if (!this.server) {
+                        resolve();
+                        return;
+                    }
+                    this.server.close((err) => {
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            resolve();
+                        }
+                    });
+                }));
+            }
+            if (this.secureServer) {
+                closePromises.push(new Promise((resolve, reject) => {
+                    if (!this.secureServer) {
+                        resolve();
+                        return;
+                    }
+                    this.secureServer.close((err) => {
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            resolve();
+                        }
+                    });
+                }));
+            }
+            // Add timeout to prevent hanging on close
+            await Promise.race([
+                Promise.all(closePromises),
+                new Promise((resolve) => {
+                    setTimeout(() => {
+                        SmtpLogger.warn('Server close timed out after 3 seconds, forcing shutdown');
+                        resolve();
+                    }, 3000);
+                })
+            ]);
+            this.server = null;
+            this.secureServer = null;
+            this.running = false;
+            SmtpLogger.info('SMTP server stopped');
+        }
+        catch (error) {
+            SmtpLogger.error(`Error stopping SMTP server: ${error instanceof Error ? error.message : String(error)}`, {
+                error: error instanceof Error ? error : new Error(String(error))
+            });
+            throw error;
+        }
+    }
+    /**
+     * Get the session manager
+     * @returns Session manager instance
+     */
+    getSessionManager() {
+        return this.sessionManager;
+    }
+    /**
+     * Get the connection manager
+     * @returns Connection manager instance
+     */
+    getConnectionManager() {
+        return this.connectionManager;
+    }
+    /**
+     * Get the command handler
+     * @returns Command handler instance
+     */
+    getCommandHandler() {
+        return this.commandHandler;
+    }
+    /**
+     * Get the data handler
+     * @returns Data handler instance
+     */
+    getDataHandler() {
+        return this.dataHandler;
+    }
+    /**
+     * Get the TLS handler
+     * @returns TLS handler instance
+     */
+    getTlsHandler() {
+        return this.tlsHandler;
+    }
+    /**
+     * Get the security handler
+     * @returns Security handler instance
+     */
+    getSecurityHandler() {
+        return this.securityHandler;
+    }
+    /**
+     * Get the server options
+     * @returns SMTP server options
+     */
+    getOptions() {
+        return this.options;
+    }
+    /**
+     * Get the email server reference
+     * @returns Email server instance
+     */
+    getEmailServer() {
+        return this.emailServer;
+    }
+    /**
+     * Check if the server is running
+     * @returns Whether the server is running
+     */
+    isRunning() {
+        return this.running;
+    }
+    /**
+     * Check if we should attempt to recover from an error
+     * @param error - The error that occurred
+     * @returns Whether recovery should be attempted
+     */
+    shouldAttemptRecovery(error) {
+        // Skip recovery if we're already in recovery mode
+        if (this.recoveryState.recovering) {
+            return false;
+        }
+        // Check if we've reached the maximum number of recovery attempts
+        if (this.recoveryState.currentRecoveryAttempt >= this.recoveryState.maxRecoveryAttempts) {
+            SmtpLogger.warn('Maximum recovery attempts reached, not attempting further recovery');
+            return false;
+        }
+        // Check if enough time has passed since the last recovery attempt
+        const now = Date.now();
+        if (now - this.recoveryState.lastRecoveryAttempt < this.recoveryState.recoveryCooldown) {
+            SmtpLogger.warn('Recovery cooldown period not elapsed, skipping recovery attempt');
+            return false;
+        }
+        // Recoverable errors include:
+        // - EADDRINUSE: Address already in use (port conflict)
+        // - ECONNRESET: Connection reset by peer
+        // - EPIPE: Broken pipe
+        // - ETIMEDOUT: Connection timed out
+        const recoverableErrors = [
+            'EADDRINUSE',
+            'ECONNRESET',
+            'EPIPE',
+            'ETIMEDOUT',
+            'ECONNABORTED',
+            'EPROTO',
+            'EMFILE' // Too many open files
+        ];
+        // Check if this is a recoverable error
+        const errorCode = error.code;
+        return recoverableErrors.includes(errorCode);
+    }
+    /**
+     * Attempt to recover the server after a critical error
+     * @param serverType - The type of server to recover ('standard' or 'secure')
+     * @param error - The error that triggered recovery
+     */
+    async attemptServerRecovery(serverType, error) {
+        // Set recovery flag to prevent multiple simultaneous recovery attempts
+        if (this.recoveryState.recovering) {
+            SmtpLogger.warn('Recovery already in progress, skipping new recovery attempt');
+            return;
+        }
+        this.recoveryState.recovering = true;
+        this.recoveryState.lastRecoveryAttempt = Date.now();
+        this.recoveryState.currentRecoveryAttempt++;
+        SmtpLogger.info(`Attempting server recovery for ${serverType} server after error: ${error.message}`, {
+            attempt: this.recoveryState.currentRecoveryAttempt,
+            maxAttempts: this.recoveryState.maxRecoveryAttempts,
+            errorCode: error.code
+        });
+        try {
+            // Determine which server to restart
+            const isStandardServer = serverType === 'standard';
+            // Close the affected server
+            if (isStandardServer && this.server) {
+                await new Promise((resolve) => {
+                    if (!this.server) {
+                        resolve();
+                        return;
+                    }
+                    // First try a clean shutdown
+                    this.server.close((err) => {
+                        if (err) {
+                            SmtpLogger.warn(`Error during server close in recovery: ${err.message}`);
+                        }
+                        resolve();
+                    });
+                    // Set a timeout to force close
+                    setTimeout(() => {
+                        resolve();
+                    }, 3000);
+                });
+                this.server = null;
+            }
+            else if (!isStandardServer && this.secureServer) {
+                await new Promise((resolve) => {
+                    if (!this.secureServer) {
+                        resolve();
+                        return;
+                    }
+                    // First try a clean shutdown
+                    this.secureServer.close((err) => {
+                        if (err) {
+                            SmtpLogger.warn(`Error during secure server close in recovery: ${err.message}`);
+                        }
+                        resolve();
+                    });
+                    // Set a timeout to force close
+                    setTimeout(() => {
+                        resolve();
+                    }, 3000);
+                });
+                this.secureServer = null;
+            }
+            // Short delay before restarting
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+            // Clean up any lingering connections
+            this.connectionManager.closeAllConnections();
+            this.sessionManager.clearAllSessions();
+            // Restart the affected server
+            if (isStandardServer) {
+                // Create and start the standard server
+                this.server = plugins.net.createServer((socket) => {
+                    // Check IP reputation before handling connection
+                    this.securityHandler.checkIpReputation(socket)
+                        .then(allowed => {
+                        if (allowed) {
+                            this.connectionManager.handleNewConnection(socket);
+                        }
+                        else {
+                            // Close connection if IP is not allowed
+                            socket.destroy();
+                        }
+                    })
+                        .catch(error => {
+                        SmtpLogger.error(`IP reputation check error: ${error instanceof Error ? error.message : String(error)}`, {
+                            remoteAddress: socket.remoteAddress,
+                            error: error instanceof Error ? error : new Error(String(error))
+                        });
+                        // Allow connection on error (fail open)
+                        this.connectionManager.handleNewConnection(socket);
+                    });
+                });
+                // Set up error handling with recovery
+                this.server.on('error', (err) => {
+                    SmtpLogger.error(`SMTP server error after recovery: ${err.message}`, { error: err });
+                    // Try to recover again if needed
+                    if (this.shouldAttemptRecovery(err)) {
+                        this.attemptServerRecovery('standard', err);
+                    }
+                });
+                // Start listening again
+                await new Promise((resolve, reject) => {
+                    if (!this.server) {
+                        reject(new Error('Server not initialized during recovery'));
+                        return;
+                    }
+                    this.server.listen(this.options.port, this.options.host, () => {
+                        SmtpLogger.info(`SMTP server recovered and listening on ${this.options.host || '0.0.0.0'}:${this.options.port}`);
+                        resolve();
+                    });
+                    // Only use error event for startup issues during recovery
+                    this.server.once('error', (err) => {
+                        SmtpLogger.error(`Failed to restart server during recovery: ${err.message}`);
+                        reject(err);
+                    });
+                });
+            }
+            else if (this.options.securePort && this.tlsHandler.isTlsEnabled()) {
+                // Try to recreate the secure server
+                try {
+                    // Import the secure server creation utility
+                    const { createSecureTlsServer } = await import('./secure-server.js');
+                    // Create secure server with the certificates
+                    this.secureServer = createSecureTlsServer({
+                        key: this.options.key,
+                        cert: this.options.cert,
+                        ca: this.options.ca
+                    });
+                    if (this.secureServer) {
+                        SmtpLogger.info(`Created secure TLS server for port ${this.options.securePort} during recovery`);
+                        // Use explicit error handling for secure connections
+                        this.secureServer.on('tlsClientError', (err, tlsSocket) => {
+                            SmtpLogger.error(`TLS client error after recovery: ${err.message}`, {
+                                error: err,
+                                remoteAddress: tlsSocket.remoteAddress,
+                                remotePort: tlsSocket.remotePort,
+                                stack: err.stack
+                            });
+                        });
+                        // Register the secure connection handler
+                        this.secureServer.on('secureConnection', (socket) => {
+                            // Check IP reputation before handling connection
+                            this.securityHandler.checkIpReputation(socket)
+                                .then(allowed => {
+                                if (allowed) {
+                                    // Pass the connection to the connection manager
+                                    this.connectionManager.handleNewSecureConnection(socket);
+                                }
+                                else {
+                                    // Close connection if IP is not allowed
+                                    socket.destroy();
+                                }
+                            })
+                                .catch(error => {
+                                SmtpLogger.error(`IP reputation check error after recovery: ${error instanceof Error ? error.message : String(error)}`, {
+                                    remoteAddress: socket.remoteAddress,
+                                    error: error instanceof Error ? error : new Error(String(error))
+                                });
+                                // Allow connection on error (fail open)
+                                this.connectionManager.handleNewSecureConnection(socket);
+                            });
+                        });
+                        // Global error handler for the secure server with recovery
+                        this.secureServer.on('error', (err) => {
+                            SmtpLogger.error(`SMTP secure server error after recovery: ${err.message}`, {
+                                error: err,
+                                stack: err.stack
+                            });
+                            // Try to recover again if needed
+                            if (this.shouldAttemptRecovery(err)) {
+                                this.attemptServerRecovery('secure', err);
+                            }
+                        });
+                        // Start listening on secure port again
+                        await new Promise((resolve, reject) => {
+                            if (!this.secureServer) {
+                                reject(new Error('Secure server not initialized during recovery'));
+                                return;
+                            }
+                            this.secureServer.listen(this.options.securePort, this.options.host, () => {
+                                SmtpLogger.info(`SMTP secure server recovered and listening on ${this.options.host || '0.0.0.0'}:${this.options.securePort}`);
+                                resolve();
+                            });
+                            // Only use error event for startup issues during recovery
+                            this.secureServer.once('error', (err) => {
+                                SmtpLogger.error(`Failed to restart secure server during recovery: ${err.message}`);
+                                reject(err);
+                            });
+                        });
+                    }
+                    else {
+                        SmtpLogger.warn('Failed to create secure server during recovery');
+                    }
+                }
+                catch (error) {
+                    SmtpLogger.error(`Error setting up secure server during recovery: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            // Recovery successful
+            SmtpLogger.info('Server recovery completed successfully');
+        }
+        catch (recoveryError) {
+            SmtpLogger.error(`Server recovery failed: ${recoveryError instanceof Error ? recoveryError.message : String(recoveryError)}`, {
+                error: recoveryError instanceof Error ? recoveryError : new Error(String(recoveryError)),
+                attempt: this.recoveryState.currentRecoveryAttempt,
+                maxAttempts: this.recoveryState.maxRecoveryAttempts
+            });
+        }
+        finally {
+            // Reset recovery flag
+            this.recoveryState.recovering = false;
+        }
+    }
+    /**
+     * Clean up all component resources
+     */
+    async destroy() {
+        SmtpLogger.info('Destroying SMTP server components');
+        // Destroy all components in parallel
+        const destroyPromises = [];
+        if (this.sessionManager && typeof this.sessionManager.destroy === 'function') {
+            destroyPromises.push(Promise.resolve(this.sessionManager.destroy()));
+        }
+        if (this.connectionManager && typeof this.connectionManager.destroy === 'function') {
+            destroyPromises.push(Promise.resolve(this.connectionManager.destroy()));
+        }
+        if (this.commandHandler && typeof this.commandHandler.destroy === 'function') {
+            destroyPromises.push(Promise.resolve(this.commandHandler.destroy()));
+        }
+        if (this.dataHandler && typeof this.dataHandler.destroy === 'function') {
+            destroyPromises.push(Promise.resolve(this.dataHandler.destroy()));
+        }
+        if (this.tlsHandler && typeof this.tlsHandler.destroy === 'function') {
+            destroyPromises.push(Promise.resolve(this.tlsHandler.destroy()));
+        }
+        if (this.securityHandler && typeof this.securityHandler.destroy === 'function') {
+            destroyPromises.push(Promise.resolve(this.securityHandler.destroy()));
+        }
+        await Promise.all(destroyPromises);
+        // Destroy the adaptive logger singleton to clean up its timer
+        const { adaptiveLogger } = await import('./utils/adaptive-logging.js');
+        if (adaptiveLogger && typeof adaptiveLogger.destroy === 'function') {
+            adaptiveLogger.destroy();
+        }
+        // Clear recovery state
+        this.recoveryState = {
+            recovering: false,
+            connectionFailures: 0,
+            lastRecoveryAttempt: 0,
+            recoveryCooldown: 5000,
+            maxRecoveryAttempts: 3,
+            currentRecoveryAttempt: 0
+        };
+        SmtpLogger.info('All SMTP server components destroyed');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smtp-server.js","sourceRoot":"","sources":["../../../../ts/mail/delivery/smtpserver/smtp-server.ts"],"names":[],"mappings":"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"}