Haraka 2.8.28 → 3.0.1

package/plugins/queue/quarantine.js

@@ -4,12 +4,11 @@ const fs   = require('fs');
 const path = require('path');
 
 exports.register = function () {
-    const plugin = this;
 
-    plugin.load_quarantine_ini();
+    this.load_quarantine_ini();
 
-    plugin.register_hook('queue',          'quarantine');
-    plugin.register_hook('queue_outbound', 'quarantine');
+    this.register_hook('queue',          'quarantine');
+    this.register_hook('queue_outbound', 'quarantine');
 }
 
 exports.hook_init_master = function (next, server) {
@@ -19,9 +18,8 @@ exports.hook_init_master = function (next, server) {
 }
 
 exports.load_quarantine_ini = function () {
-    const plugin = this;
-    plugin.cfg = plugin.config.get('quarantine.ini', () => {
-        plugin.load_quarantine_ini();
+    this.cfg = this.config.get('quarantine.ini', () => {
+        this.load_quarantine_ini();
     })
 }
 
@@ -34,33 +32,26 @@ const zeroPad = exports.zeroPad = (n, digits) => {
 }
 
 exports.clean_tmp_directory = function (next) {
-    // At start-up; delete any files in the temporary directory
-    // NOTE: This is deliberately syncronous to ensure that this
-    //       is completed prior to any messages being received.
-    const plugin = this;
-    const tmp_dir = path.join(plugin.get_base_dir(), 'tmp');
+    const tmp_dir = path.join(this.get_base_dir(), 'tmp');
 
     if (fs.existsSync(tmp_dir)) {
         const dirent = fs.readdirSync(tmp_dir);
-        plugin.loginfo(`Removing temporary files from: ${tmp_dir}`);
-        for (let i=0; i<dirent.length; i++) {
-            fs.unlinkSync(path.join(tmp_dir, dirent[i]));
+        this.loginfo(`Removing temporary files from: ${tmp_dir}`);
+        for (const element of dirent) {
+            fs.unlinkSync(path.join(tmp_dir, element));
         }
     }
     next();
 }
 
 function wants_quarantine (connection) {
-    if (connection.notes.quarantine)
-        return connection.notes.quarantine;
+    const { notes, transaction } = connection ?? {}
 
-    if (connection.transaction.notes.quarantine)
-        return connection.transaction.notes.quarantine;
+    if (notes.quarantine) return notes.quarantine;
 
-    if (connection.transaction.notes.get('queue.wants') === 'quarantine')
-        return true;
+    if (transaction.notes.quarantine) return transaction.notes.quarantine;
 
-    return false;
+    return transaction.notes.get('queue.wants') === 'quarantine';
 }
 
 exports.get_base_dir = function () {
@@ -69,19 +60,17 @@ exports.get_base_dir = function () {
 }
 
 exports.init_quarantine_dir = function (done) {
-    const plugin = this;
-    const tmp_dir = path.join(plugin.get_base_dir(), 'tmp');
+    const tmp_dir = path.join(this.get_base_dir(), 'tmp');
     fs.promises.mkdir(tmp_dir, { recursive: true })
-        .then(made => plugin.loginfo(`created ${tmp_dir}`))
-        .catch(err => plugin.logerror(`Unable to create ${tmp_dir}`))
+        .then(made => this.loginfo(`created ${tmp_dir}`))
+        .catch(err => this.logerror(`Unable to create ${tmp_dir}`))
         .finally(done);
 }
 
 exports.quarantine = function (next, connection) {
-    const plugin = this;
 
     const quarantine = wants_quarantine(connection);
-    plugin.logdebug(`quarantine: ${quarantine}`);
+    this.logdebug(`quarantine: ${quarantine}`);
     if (!quarantine) return next();
 
     // Calculate date in YYYYMMDD format
@@ -96,8 +85,10 @@ exports.quarantine = function (next, connection) {
         subdir = path.join(quarantine, yyyymmdd);
     }
 
-    const txn      = connection.transaction;
-    const base_dir = plugin.get_base_dir();
+    const txn = connection?.transaction;
+    if (!txn) return next();
+
+    const base_dir = this.get_base_dir();
     const msg_dir  = path.join(base_dir, subdir);
     const tmp_path = path.join(base_dir, 'tmp', txn.uuid);
     const msg_path = path.join(msg_dir, txn.uuid);
@@ -109,25 +100,25 @@ exports.quarantine = function (next, connection) {
     // final destination.
     fs.promises.mkdir(msg_dir, { recursive: true })
         .catch(err => {
-            connection.logerror(plugin, `Error creating directory: ${msg_dir}`);
+            connection.logerror(this, `Error creating directory: ${msg_dir}`);
             next();
         })
         .then(ok => {
             const ws = fs.createWriteStream(tmp_path);
 
             ws.on('error', err => {
-                connection.logerror(plugin, `Error writing quarantine file: ${err.message}`);
+                connection.logerror(this, `Error writing quarantine file: ${err.message}`);
                 return next();
             });
             ws.on('close', () => {
                 fs.link(tmp_path, msg_path, err => {
                     if (err) {
-                        connection.logerror(plugin, `Error writing quarantine file: ${err}`);
+                        connection.logerror(this, `Error writing quarantine file: ${err}`);
                     }
                     else {
                         // Add a note to where we stored the message
                         txn.notes.quarantined = msg_path;
-                        txn.results.add(plugin, { pass: msg_path, emit: true });
+                        txn.results.add(this, { pass: msg_path, emit: true });
                         // Now delete the temporary file
                         fs.unlink(tmp_path, () => {});
                     }

package/plugins/queue/rabbitmq.js

@@ -20,6 +20,8 @@ exports.register = function () {
 
 //Actual magic of publishing message to rabbit when email comes happen here.
 exports.hook_queue = (next, connection) => {
+    if (!connection?.transaction) return next();
+
     //Calling the get_data method and when it gets the data on callback, publish the message to queue with routing key.
     connection.transaction.message_stream.get_data(buffere => {
         const exchangeData = exports.exchangeMapping[exchangeName + queueName]
@@ -51,11 +53,10 @@ exports.hook_queue = (next, connection) => {
 
 //This initializes the connection to rabbitmq server, It reads values from rabbitmq.ini file in config directory.
 exports.init_rabbitmq_server = function () {
-    const plugin = this;
     // this is called during init of rabbitmq
 
     //Read the config file rabbitmq
-    const config     = plugin.config.get('rabbitmq.ini');
+    const config     = this.config.get('rabbitmq.ini');
     //Just putting the defaults
     const options = {};
     let confirm = true;

package/plugins/queue/rabbitmq_amqplib.js

@@ -11,20 +11,20 @@ exports.register = function () {
 }
 
 exports.rabbitmq_queue = function (next, connection) {
-    const plugin = this;
+    if (!connection?.transaction) return next();
+
     connection.transaction.message_stream.get_data(str => {
-        if (channel && channel.sendToQueue(queue, str, {deliveryMode})) {
+        if (channel?.sendToQueue(queue, str, {deliveryMode})) {
             return next(OK);
         }
         else {
-            plugin.logerror("Failed to queue to rabbitmq");
+            this.logerror("Failed to queue to rabbitmq");
             return next();
         }
     });
 }
 
 exports.init_amqp_connection = function () {
-    const plugin = this;
     const cfg = this.config.get("rabbitmq.ini").rabbitmq;
 
     const protocol = cfg.protocol || "amqp";
@@ -43,30 +43,30 @@ exports.init_amqp_connection = function () {
 
     amqp.connect(`${protocol}://${encodeURIComponent(user)}:${encodeURIComponent(password)}@${host}:${port}${vhost}`, (err, conn) => {
         if (err) {
-            plugin.logerror(`Connection to rabbitmq failed: ${err}`);
+            this.logerror(`Connection to rabbitmq failed: ${err}`);
             return;
         }
         // TODO: if !confirm conn.createChannel...
         conn.createConfirmChannel((err2, ch) => {
             if (err2) {
-                plugin.logerror(`Error creating rabbitmq channel: ${err2}`);
+                this.logerror(`Error creating rabbitmq channel: ${err2}`);
                 return conn.close();
             }
             ch.assertExchange(exchangeName, exchangeType, {durable}, (err3, ok) => {
                 if (err3) {
-                    plugin.logerror(`Error asserting rabbitmq exchange: ${err3}`);
+                    this.logerror(`Error asserting rabbitmq exchange: ${err3}`);
                     return conn.close();
                 }
                 ch.assertQueue(queueName,
                     {durable, autoDelete},
                     (err4, ok2) => {
                         if (err4) {
-                            plugin.logerror(`Error asserting rabbitmq queue: ${err4}`);
+                            this.logerror(`Error asserting rabbitmq queue: ${err4}`);
                             return conn.close();
                         }
                         queue = ok2.queue;
                         channel = ch;
-                        plugin.register_hook('queue', 'rabbitmq_queue');
+                        this.register_hook('queue', 'rabbitmq_queue');
                     }
                 );
             });

package/plugins/queue/smtp_bridge.js

@@ -6,14 +6,15 @@ exports.register = function () {
 }
 
 exports.load_flat_ini = function () {
-    const plugin = this;
-    plugin.cfg = plugin.config.get('smtp_bridge.ini', () => {
-        plugin.load_flat_ini();
+    this.cfg = this.config.get('smtp_bridge.ini', () => {
+        this.load_flat_ini();
     });
 }
 
 exports.hook_data_post = (next, connection) => {
-    const txn = connection.transaction;
+    const txn = connection?.transaction;
+    if (!txn) return next();
+
     // Copy auth notes to transaction notes so they're available in hmail.todo.notes
     txn.notes.auth_user = connection.notes.auth_user;
     txn.notes.auth_passwd = connection.notes.auth_passwd;

package/plugins/queue/smtp_forward.js

@@ -9,33 +9,35 @@ const url = require('url');
 const smtp_client_mod = require('./smtp_client');
 
 exports.register = function () {
-    const plugin = this;
-    plugin.load_errs = [];
+    this.load_errs = [];
 
-    plugin.load_smtp_forward_ini();
+    this.load_smtp_forward_ini();
 
-    if (plugin.load_errs.length > 0) return;
+    if (this.load_errs.length > 0) return;
 
-    if (plugin.cfg.main.check_sender) {
-        plugin.register_hook('mail', 'check_sender');
+    if (this.cfg.main.check_sender) {
+        this.register_hook('mail', 'check_sender');
     }
 
-    if (plugin.cfg.main.check_recipient) {
-        plugin.register_hook('rcpt', 'check_recipient');
+    if (this.cfg.main.check_recipient) {
+        this.register_hook('rcpt', 'check_recipient');
     }
 
-    plugin.register_hook('queue', 'queue_forward');
+    this.register_hook('queue', 'queue_forward');
+
+    if (this.cfg.main.enable_outbound) {
+        this.register_hook('queue_outbound', 'queue_forward');
+    }
 
-    plugin.register_hook('get_mx', 'get_mx'); // for relaying outbound messages
+    this.register_hook('get_mx', 'get_mx'); // for relaying outbound messages
 }
 
 exports.load_smtp_forward_ini = function () {
-    const plugin = this;
 
-    plugin.cfg = plugin.config.get('smtp_forward.ini', {
+    this.cfg = this.config.get('smtp_forward.ini', {
         booleans: [
             '-main.enable_tls',
-            '+main.enable_outbound',
+            '-main.enable_outbound',
             'main.one_message_per_rcpt',
             '-main.check_sender',
             '-main.check_recipient',
@@ -44,93 +46,86 @@ exports.load_smtp_forward_ini = function () {
         ],
     },
     () => {
-        plugin.load_smtp_forward_ini();
+        this.load_smtp_forward_ini();
     });
-
-    if (plugin.cfg.main.enable_outbound) {
-        plugin.lognotice('outbound enabled, will default to disabled in Haraka v3 (see #1472)');
-    }
 }
 
 exports.get_config = function (conn) {
-    const plugin = this;
 
-    if (!conn.transaction) return plugin.cfg.main;
+    if (!conn.transaction) return this.cfg.main;
 
     let dom;
-    if (plugin.cfg.main.domain_selector === 'mail_from') {
-        if (!conn.transaction.mail_from) return plugin.cfg.main;
+    if (this.cfg.main.domain_selector === 'mail_from') {
+        if (!conn.transaction.mail_from) return this.cfg.main;
         dom = conn.transaction.mail_from.host;
     }
     else {
-        if (!conn.transaction.rcpt_to[0]) return plugin.cfg.main;
+        if (!conn.transaction.rcpt_to[0]) return this.cfg.main;
         dom = conn.transaction.rcpt_to[0].host;
     }
 
-    if (!dom)             return plugin.cfg.main;
-    if (!plugin.cfg[dom]) return plugin.cfg.main;  // no specific route
+    if (!dom)             return this.cfg.main;
+    if (!this.cfg[dom]) return this.cfg.main;  // no specific route
 
-    return plugin.cfg[dom];
+    return this.cfg[dom];
 }
 
 exports.is_outbound_enabled = function (dom_cfg) {
-    const plugin = this;
 
     if ('enable_outbound' in dom_cfg) return dom_cfg.enable_outbound; // per-domain flag
 
-    return plugin.cfg.main.enable_outbound; // follow the global configuration
+    return this.cfg.main.enable_outbound; // follow the global configuration
 };
 
 exports.check_sender = function (next, connection, params) {
-    const plugin = this;
-    if (!connection.transaction) return;
-    const txn = connection.transaction;
+    const txn = connection?.transaction;
+    if (!txn) return;
 
     const email = params[0].address();
     if (!email) {
-        txn.results.add(plugin, {skip: 'mail_from.null', emit: true});
+        txn.results.add(this, {skip: 'mail_from.null', emit: true});
         return next();
     }
 
     const domain = params[0].host.toLowerCase();
-    if (!plugin.cfg[domain]) return next();
+    if (!this.cfg[domain]) return next();
 
     // domain is defined in smtp_forward.ini
     txn.notes.local_sender = true;
 
     if (!connection.relaying) {
-        txn.results.add(plugin, {fail: 'mail_from!spoof'});
+        txn.results.add(this, {fail: 'mail_from!spoof'});
         return next(DENY, "Spoofed MAIL FROM");
     }
 
-    txn.results.add(plugin, {pass: 'mail_from'});
+    txn.results.add(this, {pass: 'mail_from'});
     return next();
 }
 
 exports.set_queue = function (connection, queue_wanted, domain) {
-    const plugin = this;
 
-    let dom_cfg = plugin.cfg[domain];
+    let dom_cfg = this.cfg[domain];
     if (dom_cfg === undefined) dom_cfg = {};
 
-    if (!queue_wanted) queue_wanted = dom_cfg.queue || plugin.cfg.main.queue;
+    if (!queue_wanted) queue_wanted = dom_cfg.queue || this.cfg.main.queue;
     if (!queue_wanted) return true;
 
-    let dst_host = dom_cfg.host || plugin.cfg.main.host;
+
+    let dst_host = dom_cfg.host || this.cfg.main.host;
     if (dst_host) dst_host = `smtp://${dst_host}`;
 
-    const notes = connection.transaction.notes;
+    const notes = connection?.transaction?.notes;
+    if (!notes) return false;
     if (!notes.get('queue.wants')) {
         notes.set('queue.wants', queue_wanted);
-        if (dst_host) {
-            notes.set('queue.next_hop', dst_host);
-        }
+        if (dst_host) notes.set('queue.next_hop', dst_host);
         return true;
     }
 
     // multiple recipients with same destination
     if (notes.get('queue.wants') === queue_wanted) {
         if (!dst_host) return true;
+
         const next_hop = notes.get('queue.next_hop');
         if (!next_hop) return true;
         if (next_hop === dst_host) return true;
@@ -141,49 +136,47 @@ exports.set_queue = function (connection, queue_wanted, domain) {
 }
 
 exports.check_recipient = function (next, connection, params) {
-    const plugin = this;
-    const txn = connection.transaction;
+    const txn = connection?.transaction;
     if (!txn) return;
 
     const rcpt = params[0];
     if (!rcpt.host) {
-        txn.results.add(plugin, {skip: 'rcpt!domain'});
+        txn.results.add(this, {skip: 'rcpt!domain'});
         return next();
     }
 
     if (connection.relaying && txn.notes.local_sender) {
-        plugin.set_queue(connection, 'outbound');
-        txn.results.add(plugin, {pass: 'relaying local_sender'});
+        this.set_queue(connection, 'outbound');
+        txn.results.add(this, {pass: 'relaying local_sender'});
         return next(OK);
     }
 
     const domain = rcpt.host.toLowerCase();
-    if (plugin.cfg[domain] !== undefined) {
-        if (plugin.set_queue(connection, 'smtp_forward', domain)) {
-            txn.results.add(plugin, {pass: 'rcpt_to'});
+    if (this.cfg[domain] !== undefined) {
+        if (this.set_queue(connection, 'smtp_forward', domain)) {
+            txn.results.add(this, {pass: 'rcpt_to'});
             return next(OK);
         }
-        txn.results.add(plugin, {pass: 'rcpt_to.split'});
+        txn.results.add(this, {pass: 'rcpt_to.split'});
         return next(DENYSOFT, "Split transaction, retry soon");
     }
 
     // the MAIL FROM domain is not local and neither is the RCPT TO
     // Another RCPT plugin may vouch for this recipient.
-    txn.results.add(plugin, {msg: 'rcpt!local'});
+    txn.results.add(this, {msg: 'rcpt!local'});
     return next();
 }
 
 exports.auth = function (cfg, connection, smtp_client) {
-    const plugin = this;
 
-    connection.loginfo(plugin, `Configuring authentication for SMTP server ${cfg.host}:${cfg.port}`);
+    connection.loginfo(this, `Configuring authentication for SMTP server ${cfg.host}:${cfg.port}`);
     smtp_client.on('capabilities', () => {
-        connection.loginfo(plugin, 'capabilities received');
+        connection.loginfo(this, 'capabilities received');
 
         if ('secured' in smtp_client) {
-            connection.loginfo(plugin, 'secured is pending');
+            connection.loginfo(this, 'secured is pending');
             if (smtp_client.secured === false) {
-                connection.loginfo(plugin, "Waiting for STARTTLS to complete. AUTH postponed");
+                connection.loginfo(this, "Waiting for STARTTLS to complete. AUTH postponed");
                 return;
             }
         }
@@ -194,18 +187,19 @@ exports.auth = function (cfg, connection, smtp_client) {
         }
 
         if (cfg.auth_type === 'plain') {
-            connection.loginfo(plugin, `Authenticating with AUTH PLAIN ${cfg.auth_user}`);
+            connection.loginfo(this, `Authenticating with AUTH PLAIN ${cfg.auth_user}`);
             smtp_client.send_command('AUTH', `PLAIN ${base64(`\0${cfg.auth_user}\0${cfg.auth_pass}`)}`);
+            return
         }
-        else if (cfg.auth_type === 'login') {
+
+        if (cfg.auth_type === 'login') {
             smtp_client.authenticating = true;
             smtp_client.authenticated = false;
 
-            connection.loginfo(plugin, `Authenticating with AUTH LOGIN ${cfg.auth_user}`);
+            connection.loginfo(this, `Authenticating with AUTH LOGIN ${cfg.auth_user}`);
             smtp_client.send_command('AUTH', 'LOGIN');
             smtp_client.on('auth', () => {
-                //TODO: nothing?
-
+                // do nothing
             });
             smtp_client.on('auth_username', () => {
                 smtp_client.send_command(base64(cfg.auth_user));
@@ -218,16 +212,15 @@ exports.auth = function (cfg, connection, smtp_client) {
 }
 
 exports.forward_enabled = function (conn, dom_cfg) {
-    const plugin = this;
 
     const q_wants = conn.transaction.notes.get('queue.wants');
     if (q_wants && q_wants !== 'smtp_forward') {
-        conn.logdebug(plugin, `skipping, unwanted (${q_wants})`);
+        conn.logdebug(this, `skipping, unwanted (${q_wants})`);
         return false;
     }
 
-    if (conn.relaying && !plugin.is_outbound_enabled(dom_cfg)) {
-        conn.logdebug(plugin, 'skipping, outbound disabled');
+    if (conn.relaying && !this.is_outbound_enabled(dom_cfg)) {
+        conn.logdebug(this, 'skipping, outbound disabled');
         return false;
     }
 
@@ -236,30 +229,29 @@ exports.forward_enabled = function (conn, dom_cfg) {
 
 exports.queue_forward = function (next, connection) {
     const plugin = this;
-    const conn = connection;
-    const txn = connection.transaction;
+    const txn = connection?.transaction;
 
-    const cfg = plugin.get_config(conn);
-    if (!plugin.forward_enabled(conn, cfg)) return next();
+    const cfg = plugin.get_config(connection);
+    if (!plugin.forward_enabled(connection, cfg)) return next();
 
-    smtp_client_mod.get_client_plugin(plugin, conn, cfg, (err, smtp_client) => {
+    smtp_client_mod.get_client_plugin(plugin, connection, cfg, (err, smtp_client) => {
         smtp_client.next = next;
 
         let rcpt = 0;
 
-        if (cfg.auth_user) plugin.auth(cfg, conn, smtp_client);
+        if (cfg.auth_user) plugin.auth(cfg, connection, smtp_client);
 
-        conn.loginfo(plugin, `forwarding to ${
+        connection.loginfo(plugin, `forwarding to ${
             cfg.forwarding_host_pool ? 'host_pool' : `${cfg.host}:${cfg.port}`}`
         );
 
         function get_rs () {
-            if (connection.transaction) return txn.results;
-            return conn.results;
+            if (txn) return txn.results;
+            return connection.results;
         }
 
         function dead_sender () {
-            if (smtp_client.is_dead_sender(plugin, conn)) {
+            if (smtp_client.is_dead_sender(plugin, connection)) {
                 get_rs().add(plugin, { err: 'dead sender' });
                 return true;
             }
@@ -267,7 +259,7 @@ exports.queue_forward = function (next, connection) {
         }
 
         function send_rcpt () {
-            if (dead_sender()) return;
+            if (dead_sender() || !txn) return;
             if (rcpt === txn.rcpt_to.length) {
                 smtp_client.send_command('DATA');
                 return;
@@ -293,7 +285,8 @@ exports.queue_forward = function (next, connection) {
         });
 
         smtp_client.on('dot', () => {
-            if (dead_sender()) return;
+            if (dead_sender() || !txn) return;
+
             get_rs().add(plugin, { pass: smtp_client.response });
             if (rcpt < txn.rcpt_to.length) {
                 smtp_client.send_command('RSET');
@@ -304,12 +297,12 @@ exports.queue_forward = function (next, connection) {
         });
 
         smtp_client.on('rset', () => {
-            if (dead_sender()) return;
+            if (dead_sender() || !txn) return;
             smtp_client.send_command('MAIL', `FROM:${txn.mail_from}`);
         });
 
         smtp_client.on('bad_code', (code, msg) => {
-            if (dead_sender()) return;
+            if (dead_sender() || !txn) return;
             smtp_client.call_next(((code && code[0] === '5') ? DENY : DENYSOFT),
                 msg);
             smtp_client.release();
@@ -333,18 +326,17 @@ exports.get_mx_next_hop = next_hop => {
 }
 
 exports.get_mx = function (next, hmail, domain) {
-    const plugin = this;
 
     // hmail.todo not defined in tests.
     if (hmail.todo.notes.next_hop) {
-        return next(OK, plugin.get_mx_next_hop(hmail.todo.notes.next_hop));
+        return next(OK, this.get_mx_next_hop(hmail.todo.notes.next_hop));
     }
 
-    const dom = plugin.cfg.main.domain_selector === 'mail_from' ? hmail.todo.mail_from.host.toLowerCase() : domain.toLowerCase();
-    const cfg = plugin.cfg[dom];
+    const dom = this.cfg.main.domain_selector === 'mail_from' ? hmail.todo.mail_from.host.toLowerCase() : domain.toLowerCase();
+    const cfg = this.cfg[dom];
 
     if (cfg === undefined) {
-        plugin.logdebug(`using DNS MX for: ${domain}`);
+        this.logdebug(`using DNS MX for: ${domain}`);
         return next();
     }
 
@@ -355,14 +347,14 @@ exports.get_mx = function (next, hmail, domain) {
 
     const mx = {
         priority: 0,
-        exchange: cfg.host || plugin.cfg.main.host,
-        port: cfg.port || plugin.cfg.main.port || 25,
+        exchange: cfg.host || this.cfg.main.host,
+        port: cfg.port || this.cfg.main.port || 25,
     }
 
     // apply auth/mx options
     mx_opts.forEach(o => {
         if (cfg[o] === undefined) return;
-        mx[o] = plugin.cfg[dom][o];
+        mx[o] = this.cfg[dom][o];
     })
 
     return next(OK, mx);