Haraka 2.8.28 → 3.0.1

package/plugins/queue/smtp_proxy.js

@@ -7,40 +7,37 @@
 const smtp_client_mod = require('./smtp_client');
 
 exports.register = function () {
-    const plugin = this;
 
-    plugin.load_smtp_proxy_ini();
+    this.load_smtp_proxy_ini();
 
-    if (plugin.cfg.main.enable_outbound) {
-        plugin.register_hook('queue_outbound', 'hook_queue');
+    if (this.cfg.main.enable_outbound) {
+        this.register_hook('queue_outbound', 'hook_queue');
     }
 }
 
 exports.load_smtp_proxy_ini = function () {
-    const plugin = this;
 
-    plugin.cfg = plugin.config.get('smtp_proxy.ini', {
+    this.cfg = this.config.get('smtp_proxy.ini', {
         booleans: [
             '-main.enable_tls',
             '+main.enable_outbound',
         ],
     },
     () => {
-        plugin.load_smtp_proxy_ini();
+        this.load_smtp_proxy_ini();
     });
 
-    if (plugin.cfg.main.enable_outbound) {
-        plugin.lognotice('outbound enabled, will default to disabled in Haraka v3 (see #1472)');
+    if (this.cfg.main.enable_outbound) {
+        this.lognotice('outbound enabled, will default to disabled in Haraka v3 (see #1472)');
     }
 }
 
 exports.hook_mail = function (next, connection, params) {
-    const plugin = this;
-    const c = plugin.cfg.main;
-    connection.loginfo(plugin, `forwarding to ${
+    const c = this.cfg.main;
+    connection.loginfo(this, `forwarding to ${
         c.forwarding_host_pool ? "configured forwarding_host_pool" : `${c.host}:${c.port}`}`
     );
-    smtp_client_mod.get_client_plugin(plugin, connection, c, (err, smtp_client) => {
+    smtp_client_mod.get_client_plugin(this, connection, c, (err, smtp_client) => {
         connection.notes.smtp_client = smtp_client;
         smtp_client.next = next;
 
@@ -49,7 +46,7 @@ exports.hook_mail = function (next, connection, params) {
         smtp_client.on('data', smtp_client.call_next);
 
         smtp_client.on('dot', () => {
-            if (smtp_client.is_dead_sender(plugin, connection)) {
+            if (smtp_client.is_dead_sender(this, connection)) {
                 delete connection.notes.smtp_client;
                 return;
             }
@@ -71,7 +68,7 @@ exports.hook_mail = function (next, connection, params) {
                 // errors are OK for rcpt, but nothing else
                 // this can also happen if the destination server
                 // times out, but that is okay.
-                connection.loginfo(plugin, "message denied, proxying failed");
+                connection.loginfo(this, "message denied, proxying failed");
                 smtp_client.release();
                 delete connection.notes.smtp_client;
             }
@@ -80,25 +77,27 @@ exports.hook_mail = function (next, connection, params) {
 }
 
 exports.hook_rcpt_ok = (next, connection, recipient) => {
-    const smtp_client = connection.notes.smtp_client;
+    const { smtp_client } = connection.notes;
     if (!smtp_client) return next();
     smtp_client.next = next;
     smtp_client.send_command('RCPT', `TO:${recipient.format(!smtp_client.smtp_utf8)}`);
 }
 
 exports.hook_data = (next, connection) => {
-    const smtp_client = connection.notes.smtp_client;
+    const { smtp_client } = connection.notes;
     if (!smtp_client) return next();
     smtp_client.next = next;
     smtp_client.send_command("DATA");
 }
 
 exports.hook_queue = function (next, connection) {
-    const plugin = this;
-    const smtp_client = connection.notes.smtp_client;
+    if (!connection?.transaction || !connection?.notes) return next();
+
+    const { smtp_client } = connection.notes;
     if (!smtp_client) return next();
+
     smtp_client.next = next;
-    if (smtp_client.is_dead_sender(plugin, connection)) {
+    if (smtp_client.is_dead_sender(this, connection)) {
         delete connection.notes.smtp_client;
         return;
     }
@@ -106,7 +105,7 @@ exports.hook_queue = function (next, connection) {
 }
 
 exports.hook_rset = (next, connection) => {
-    const smtp_client = connection.notes.smtp_client;
+    const { smtp_client } = connection.notes;
     if (!smtp_client) return next();
     smtp_client.release();
     delete connection.notes.smtp_client;
@@ -116,7 +115,7 @@ exports.hook_rset = (next, connection) => {
 exports.hook_quit = exports.hook_rset;
 
 exports.hook_disconnect = (next, connection) => {
-    const smtp_client = connection.notes.smtp_client;
+    const { smtp_client } = connection.notes;
     if (!smtp_client) return next();
     smtp_client.release();
     delete connection.notes.smtp_client;

package/plugins/queue/test.js

@@ -1,10 +1,11 @@
-
 const fs = require('fs');
 const os = require('os');
 
 const tempDir = os.tmpdir();
 
 exports.hook_queue = function (next, connection) {
+    if (!connection?.transaction) return next();
+
     const ws = fs.createWriteStream(`${tempDir}/mail.eml`);
     connection.logdebug(this, `Saving to ${tempDir}/mail.eml`);
     ws.once('close', () => next(OK));

package/plugins/rcpt_to.host_list_base.js

@@ -2,78 +2,68 @@
 // Base class for plugins that use config/host_list
 
 exports.load_host_list = function () {
-    const plugin = this;
 
     const lowered_list = {};  // assemble
-    const raw_list = plugin.config.get('host_list', 'list', () => {
-        plugin.load_host_list();
+    const raw_list = this.config.get('host_list', 'list', () => {
+        this.load_host_list();
     });
 
     for (const i in raw_list) {
         lowered_list[raw_list[i].toLowerCase()] = true;
     }
 
-    plugin.host_list = lowered_list;
+    this.host_list = lowered_list;
 }
 
 exports.load_host_list_regex = function () {
-    const plugin = this;
 
-    plugin.host_list_regex = plugin.config.get(
+    this.host_list_regex = this.config.get(
         'host_list_regex',
         'list',
-        () => { plugin.load_host_list_regex(); }
+        () => { this.load_host_list_regex(); }
     );
 
-    plugin.hl_re = new RegExp (`^(?:${
-        plugin.host_list_regex.join('|')})$`, 'i');
+    this.hl_re = new RegExp (`^(?:${this.host_list_regex.join('|')})$`, 'i');
 }
 
 exports.hook_mail = function (next, connection, params) {
-    const plugin = this;
-    const txn = connection.transaction;
-    if (!txn) { return; }
+    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();
 
-    const anti_spoof = plugin.config.get('host_list.anti_spoof') || false;
+    const anti_spoof = this.config.get('host_list.anti_spoof') || false;
 
-    if (plugin.in_host_list(domain) || plugin.in_host_regex(domain)) {
+    if (this.in_host_list(domain) || this.in_host_regex(domain)) {
         if (anti_spoof && !connection.relaying) {
-            txn.results.add(plugin, {fail: 'mail_from.anti_spoof'});
+            txn.results.add(this, {fail: 'mail_from.anti_spoof'});
             return next(DENY, `Mail from domain '${domain}' is not allowed from your host`);
         }
-        txn.results.add(plugin, {pass: 'mail_from'});
+        txn.results.add(this, {pass: 'mail_from'});
         txn.notes.local_sender = true;
         return next();
     }
 
-    txn.results.add(plugin, {msg: 'mail_from!local'});
+    txn.results.add(this, {msg: 'mail_from!local'});
     return next();
 }
 
 exports.in_host_list = function (domain) {
-    const plugin = this;
-    plugin.logdebug(`checking ${domain} in config/host_list`);
-    if (plugin.host_list[domain]) {
-        return true;
-    }
-    return false;
+    this.logdebug(`checking ${domain} in config/host_list`);
+    return !!(this.host_list[domain]);
 }
 
 exports.in_host_regex = function (domain) {
-    const plugin = this;
-    if (!plugin.host_list_regex) return false;
-    if (!plugin.host_list_regex.length) return false;
+    if (!this.host_list_regex) return false;
+    if (!this.host_list_regex.length) return false;
 
-    plugin.logdebug(`checking ${domain} against config/host_list_regex `);
+    this.logdebug(`checking ${domain} against config/host_list_regex `);
 
-    if (plugin.hl_re.test(domain)) { return true; }
-    return false;
+    return !!(this.hl_re.test(domain));
 }

package/plugins/rcpt_to.in_host_list.js

@@ -10,49 +10,47 @@
 // is enabled and the sending domain is local, the receipt is OK.
 
 exports.register = function () {
-    const plugin = this;
-    plugin.inherits('rcpt_to.host_list_base');
+    this.inherits('rcpt_to.host_list_base');
 
-    plugin.load_host_list();
-    plugin.load_host_list_regex();
+    this.load_host_list();
+    this.load_host_list_regex();
 }
 
 exports.hook_rcpt = function (next, connection, params) {
-    const plugin = this;
-    const txn = connection.transaction;
+    const txn = connection?.transaction;
     if (!txn) return;
 
     const rcpt = params[0];
 
     // Check for RCPT TO without an @ first - ignore those here
     if (!rcpt.host) {
-        txn.results.add(plugin, {fail: 'rcpt!domain'});
+        txn.results.add(this, {fail: 'rcpt!domain'});
         return next();
     }
 
-    connection.logdebug(plugin, `Checking if ${rcpt} host is in host_list`);
+    connection.logdebug(this, `Checking if ${rcpt} host is in host_list`);
 
     const domain = rcpt.host.toLowerCase();
 
-    if (plugin.in_host_list(domain)) {
-        txn.results.add(plugin, {pass: 'rcpt_to'});
+    if (this.in_host_list(domain)) {
+        txn.results.add(this, {pass: 'rcpt_to'});
         return next(OK);
     }
 
-    if (plugin.in_host_regex(domain)) {
-        txn.results.add(plugin, {pass: 'rcpt_to'});
+    if (this.in_host_regex(domain)) {
+        txn.results.add(this, {pass: 'rcpt_to'});
         return next(OK);
     }
 
     // in this case, a client with relaying privileges is sending FROM a local
     // domain. For them, any RCPT address is accepted.
     if (connection.relaying && txn.notes.local_sender) {
-        txn.results.add(plugin, {pass: 'relaying local_sender'});
+        txn.results.add(this, {pass: 'relaying local_sender'});
         return next(OK);
     }
 
     // the MAIL FROM domain is not local and neither is the RCPT TO
     // Another RCPT plugin may yet vouch for this recipient.
-    txn.results.add(plugin, {msg: 'rcpt!local'});
+    txn.results.add(this, {msg: 'rcpt!local'});
     return next();
 }

package/plugins/rcpt_to.max_count.js

@@ -5,17 +5,19 @@
 // Consider using the karma plugin. It supports limiting the number
 // of recipients based on past behavior (good, bad, unknown)
 
-exports.hook_rcpt = function (next, connection) {
-    if (connection.transaction.notes.rcpt_to_count) {
-        connection.transaction.notes.rcpt_to_count++;
+exports.hook_rcpt = function (next, connection = {}) {
+    const { notes } = connection.transaction
+
+    if (notes?.rcpt_to_count) {
+        notes.rcpt_to_count++;
     }
     else {
-        connection.transaction.notes.rcpt_to_count = 1;
+        notes.rcpt_to_count = 1;
     }
 
     const max_count = this.config.get('rcpt_to.max_count') || 40;
 
-    if (connection.transaction.notes.rcpt_to_count > max_count) {
+    if (notes.rcpt_to_count > max_count) {
         return next(DENYDISCONNECT, "Too many recipient attempts");
     }
     return next();

package/plugins/record_envelope_addresses.js

@@ -3,17 +3,15 @@
 // documentation via: haraka -h plugins/record_envelope_addresses
 
 exports.hook_rcpt = (next, connection, params) => {
-    const txn = connection.transaction;
-    if (txn) {
-        txn.add_header('X-Envelope-To', params[0].address());
+    if (connection?.transaction) {
+        connection.transaction.add_header('X-Envelope-To', params[0].address());
     }
     next();
 }
 
 exports.hook_mail = (next, connection, params) => {
-    const txn = connection.transaction;
-    if (txn) {
-        txn.add_header('X-Envelope-From', params[0].address());
+    if (connection?.transaction) {
+        connection.transaction.add_header('X-Envelope-From', params[0].address());
     }
     next();
 }

package/plugins/relay.js

@@ -6,36 +6,34 @@ const ipaddr = require('ipaddr.js');
 const net    = require('net');
 
 exports.register = function () {
-    const plugin = this;
 
-    plugin.load_relay_ini();             // plugin.cfg = { }
+    this.load_relay_ini();             // plugin.cfg = { }
 
-    if (plugin.cfg.relay.acl) {
-        plugin.load_acls();             // plugin.acl_allow = [..]
-        plugin.register_hook('connect_init', 'acl');
-        plugin.register_hook('connect', 'pass_relaying');
+    if (this.cfg.relay.acl) {
+        this.load_acls();             // plugin.acl_allow = [..]
+        this.register_hook('connect_init', 'acl');
+        this.register_hook('connect', 'pass_relaying');
     }
 
-    if (plugin.cfg.relay.force_routing || plugin.cfg.relay.dest_domains) {
-        plugin.load_dest_domains();      // plugin.dest.domains = { }
+    if (this.cfg.relay.force_routing || this.cfg.relay.dest_domains) {
+        this.load_dest_domains();      // plugin.dest.domains = { }
     }
 
-    if (plugin.cfg.relay.force_routing) {
-        plugin.register_hook('get_mx', 'force_routing');
+    if (this.cfg.relay.force_routing) {
+        this.register_hook('get_mx', 'force_routing');
     }
 
-    if (plugin.cfg.relay.dest_domains) {
-        plugin.register_hook('rcpt', 'dest_domains');
+    if (this.cfg.relay.dest_domains) {
+        this.register_hook('rcpt', 'dest_domains');
     }
 
-    if (plugin.cfg.relay.all) {
-        plugin.register_hook('rcpt', 'all');
+    if (this.cfg.relay.all) {
+        this.register_hook('rcpt', 'all');
     }
 }
 
 exports.load_relay_ini = function () {
-    const plugin = this;
-    plugin.cfg = plugin.config.get('relay.ini', {
+    this.cfg = this.config.get('relay.ini', {
         booleans: [
             '+relay.acl',
             '+relay.force_routing',
@@ -43,52 +41,49 @@ exports.load_relay_ini = function () {
             '-relay.dest_domains',
         ],
     }, () => {
-        plugin.load_relay_ini();
+        this.load_relay_ini();
     });
 }
 
 exports.load_dest_domains = function () {
-    const plugin = this;
-    plugin.dest = plugin.config.get(
+    this.dest = this.config.get(
         'relay_dest_domains.ini',
         'ini',
-        () => { plugin.load_dest_domains(); }
+        () => { this.load_dest_domains(); }
     );
 }
 
 exports.load_acls = function () {
-    const plugin = this;
     const file_name = 'relay_acl_allow';
 
     // load with a self-referential callback
-    plugin.acl_allow = plugin.config.get(file_name, 'list', () => {
-        plugin.load_acls();
+    this.acl_allow = this.config.get(file_name, 'list', () => {
+        this.load_acls();
     });
 
-    for (let i=0; i<plugin.acl_allow.length; i++) {
-        const cidr = plugin.acl_allow[i].split('/');
+    for (let i=0; i<this.acl_allow.length; i++) {
+        const cidr = this.acl_allow[i].split('/');
         if (!net.isIP(cidr[0])) {
-            plugin.logerror(plugin, `invalid entry in ${file_name}: ${cidr[0]}`);
+            this.logerror(this, `invalid entry in ${file_name}: ${cidr[0]}`);
         }
         if (!cidr[1]) {
-            plugin.logerror(plugin, `appending missing CIDR suffix in: ${file_name}`);
-            plugin.acl_allow[i] = `${cidr[0]  }/32`;
+            this.logerror(this, `appending missing CIDR suffix in: ${file_name}`);
+            this.acl_allow[i] = `${cidr[0]  }/32`;
         }
     }
 }
 
 exports.acl = function (next, connection) {
-    const plugin = this;
-    if (!plugin.cfg.relay.acl) { return next(); }
+    if (!this.cfg.relay.acl) { return next(); }
 
     connection.logdebug(this, `checking ${connection.remote.ip} in relay_acl_allow`);
 
-    if (!plugin.is_acl_allowed(connection)) {
-        connection.results.add(plugin, {skip: 'acl(unlisted)'});
+    if (!this.is_acl_allowed(connection)) {
+        connection.results.add(this, {skip: 'acl(unlisted)'});
         return next();
     }
 
-    connection.results.add(plugin, {pass: 'acl'});
+    connection.results.add(this, {pass: 'acl'});
     connection.relaying = true;
     return next(OK);
 }
@@ -102,16 +97,14 @@ exports.pass_relaying = (next, connection) => {
 }
 
 exports.is_acl_allowed = function (connection) {
-    const plugin = this;
-    if (!plugin.acl_allow) { return false; }
-    if (!plugin.acl_allow.length) { return false; }
+    if (!this.acl_allow) { return false; }
+    if (!this.acl_allow.length) { return false; }
 
-    const ip = connection.remote.ip;
+    const { ip } = connection.remote;
 
-    for (let i=0; i < plugin.acl_allow.length; i++) {
-        const item = plugin.acl_allow[i];
-        connection.logdebug(plugin, `checking if ${ip} is in ${item}`);
-        const cidr = plugin.acl_allow[i].split('/');
+    for (const item of this.acl_allow) {
+        connection.logdebug(this, `checking if ${ip} is in ${item}`);
+        const cidr = item.split('/');
         const c_net  = cidr[0];
         const c_mask = cidr[1] || 32;
 
@@ -120,7 +113,7 @@ exports.is_acl_allowed = function (connection) {
         if (net.isIPv6(ip) && net.isIPv4(c_net)) continue;
 
         if (ipaddr.parse(ip).match(ipaddr.parse(c_net), c_mask)) {
-            connection.logdebug(plugin, `checking if ${ip} is in ${item}: yes`);
+            connection.logdebug(this, `checking if ${ip} is in ${item}: yes`);
             return true;
         }
     }
@@ -128,37 +121,37 @@ exports.is_acl_allowed = function (connection) {
 }
 
 exports.dest_domains = function (next, connection, params) {
-    const plugin = this;
-    if (!plugin.cfg.relay.dest_domains) { return next(); }
-    const transaction = connection.transaction;
+    if (!this.cfg.relay.dest_domains) { return next(); }
+    const { relaying, transaction } = connection ?? {}
+    if (!transaction) return next();
 
     // Skip this if the host is already allowed to relay
-    if (connection.relaying) {
-        transaction.results.add(plugin, {skip: 'relay_dest_domain(relay)'});
+    if (relaying) {
+        transaction.results.add(this, {skip: 'relay_dest_domain(relay)'});
         return next();
     }
 
-    if (!plugin.dest) {
-        transaction.results.add(plugin, {err: 'relay_dest_domain(no config!)'});
+    if (!this.dest) {
+        transaction.results.add(this, {err: 'relay_dest_domain(no config!)'});
         return next();
     }
 
-    if (!plugin.dest.domains) {
-        transaction.results.add(plugin, {skip: 'relay_dest_domain(config)'});
+    if (!this.dest.domains) {
+        transaction.results.add(this, {skip: 'relay_dest_domain(config)'});
         return next();
     }
 
     const dest_domain = params[0].host;
-    connection.logdebug(plugin, `dest_domain = ${dest_domain}`);
+    connection.logdebug(this, `dest_domain = ${dest_domain}`);
 
-    const dst_cfg = plugin.dest.domains[dest_domain];
+    const dst_cfg = this.dest.domains[dest_domain];
     if (!dst_cfg) {
-        transaction.results.add(plugin, {fail: 'relay_dest_domain'});
+        transaction.results.add(this, {fail: 'relay_dest_domain'});
         return next(DENY, "You are not allowed to relay");
     }
 
-    const action = JSON.parse(dst_cfg).action;
-    connection.logdebug(plugin, `found config for ${dest_domain}: ${action}`);
+    const { action } = JSON.parse(dst_cfg);
+    connection.logdebug(this, `found config for ${dest_domain}: ${action}`);
 
     switch (action) {
         case "accept":
@@ -166,53 +159,50 @@ exports.dest_domains = function (next, connection, params) {
             // address to be considered 'local'. What advantage does relaying
             // bring?
             connection.relaying = true;
-            transaction.results.add(plugin, {pass: 'relay_dest_domain'});
+            transaction.results.add(this, {pass: 'relay_dest_domain'});
             return next(OK);
         case "continue":
             // why oh why? Only reason I can think of is to enable outbound.
             connection.relaying = true;
-            transaction.results.add(plugin, {pass: 'relay_dest_domain'});
+            transaction.results.add(this, {pass: 'relay_dest_domain'});
             return next(CONT);  // same as next()
         case "deny":
-            transaction.results.add(plugin, {fail: 'relay_dest_domain'});
+            transaction.results.add(this, {fail: 'relay_dest_domain'});
             return next(DENY, "You are not allowed to relay");
     }
 
-    transaction.results.add(plugin, {fail: 'relay_dest_domain'});
+    transaction.results.add(this, {fail: 'relay_dest_domain'});
     return next(DENY, "Mail for that recipient is not accepted here.");
 }
 
 exports.force_routing = function (next, hmail, domain) {
-    const plugin = this;
-    if (!plugin.cfg.relay.force_routing) { return next(); }
-    if (!plugin.dest) { return next(); }
-    if (!plugin.dest.domains) { return next(); }
-    let route = plugin.dest.domains[domain];
+    if (!this.cfg.relay.force_routing) { return next(); }
+    if (!this.dest) { return next(); }
+    if (!this.dest.domains) { return next(); }
+    let route = this.dest.domains[domain];
 
     if (!route) {
-        route = plugin.dest.domains.any;
+        route = this.dest.domains.any;
         if (!route) {
-            plugin.logdebug(plugin, `using normal MX lookup for: ${domain}`);
+            this.logdebug(this, `using normal MX lookup for: ${domain}`);
             return next();
         }
     }
 
-    const nexthop = JSON.parse(route).nexthop;
+    const { nexthop } = JSON.parse(route);
     if (!nexthop) {
-        plugin.logdebug(plugin, `using normal MX lookup for: ${domain}`);
+        this.logdebug(this, `using normal MX lookup for: ${domain}`);
         return next();
     }
 
-    plugin.logdebug(plugin, `using ${nexthop} for: ${domain}`);
+    this.logdebug(this, `using ${nexthop} for: ${domain}`);
     return next(OK, nexthop);
 }
 
 exports.all = function (next, connection, params) {
-// relay everything - could be useful for a spamtrap
-    const plugin = this;
-    if (!plugin.cfg.relay.all) { return next(); }
+    if (!this.cfg.relay.all) { return next(); }
 
-    connection.loginfo(plugin, `confirming recipient ${params[0]}`);
+    connection.loginfo(this, `confirming recipient ${params[0]}`);
     connection.relaying = true;
     next(OK);
 }

package/plugins/reseed_rng.js

@@ -1,8 +1,7 @@
 const crypto = require('crypto');
 
 exports.hook_init_child = function (next) {
-    const plugin = this;
     Math.seedrandom(crypto.randomBytes(256).toString('hex'));
-    plugin.logdebug("reseeded rng");
+    this.logdebug("reseeded rng");
     next();
 }