Haraka 2.8.28 → 3.0.1

package/plugins/spamassassin.js

@@ -5,13 +5,11 @@ const sock  = require('./line_socket');
 const utils = require('haraka-utils');
 
 exports.register = function () {
-    const plugin = this;
-    plugin.load_spamassassin_ini();
+    this.load_spamassassin_ini();
 }
 
 exports.load_spamassassin_ini = function () {
-    const plugin = this;
-    plugin.cfg = plugin.config.get('spamassassin.ini', {
+    this.cfg = this.config.get('spamassassin.ini', {
         booleans: [
             '+add_headers',
             '+check.authenticated',
@@ -24,7 +22,7 @@ exports.load_spamassassin_ini = function () {
             '-defer.scan_timeout',
         ],
     }, () => {
-        plugin.load_spamassassin_ini();
+        this.load_spamassassin_ini();
     });
 
     const defaults = {
@@ -36,31 +34,29 @@ exports.load_spamassassin_ini = function () {
     };
 
     for (const key in defaults) {
-        if (plugin.cfg.main[key]) continue;
-        plugin.cfg.main[key] = defaults[key];
+        if (this.cfg.main[key]) continue;
+        this.cfg.main[key] = defaults[key];
     }
 
     [
         'reject_threshold', 'relay_reject_threshold',
         'munge_subject_threshold', 'max_size'
     ].forEach(item => {
-        if (!plugin.cfg.main[item]) return;
-        plugin.cfg.main[item] = Number(plugin.cfg.main[item]);
+        if (!this.cfg.main[item]) return;
+        this.cfg.main[item] = Number(this.cfg.main[item]);
     });
 }
 
 exports.hook_data_post = function (next, connection) {
-    const plugin = this;
-    const conn = connection;
-    const txn  = connection.transaction;
 
-    if (plugin.should_skip(conn)) return next();
+    if (this.should_skip(connection)) return next();
 
-    txn.remove_header(plugin.cfg.main.spamc_auth_header); // just to be safe
+    const txn  = connection.transaction;
+    txn.remove_header(this.cfg.main.spamc_auth_header); // just to be safe
 
-    const username        = plugin.get_spamd_username(conn);
-    const headers         = plugin.get_spamd_headers(conn, username);
-    const socket          = plugin.get_spamd_socket(next, conn, headers);
+    const username        = this.get_spamd_username(connection);
+    const headers         = this.get_spamd_headers(connection, username);
+    const socket          = this.get_spamd_socket(next, connection, headers);
 
     const spamd_response = { headers: {} };
     let state = 'line0';
@@ -68,7 +64,7 @@ exports.hook_data_post = function (next, connection) {
     const start = Date.now();
 
     socket.on('line', line => {
-        conn.logprotocol(plugin, `Spamd C: ${line} state=${state}`);
+        connection.logprotocol(this, `Spamd C: ${line} state=${state}`);
         line = line.replace(/\r?\n/, '');
         if (state === 'line0') {
             spamd_response.line0 = line;
@@ -92,7 +88,7 @@ exports.hook_data_post = function (next, connection) {
         else if (state === 'headers') {
             const m = line.match(/^X-Spam-([\x21-\x39\x3B-\x7E]+):\s*(.*)/);
             if (m) {
-                conn.logdebug(plugin, `header: ${line}`);
+                connection.logdebug(this, `header: ${line}`);
                 last_header = m[1];
                 spamd_response.headers[m[1]] = m[2];
                 return;
@@ -107,14 +103,14 @@ exports.hook_data_post = function (next, connection) {
     });
 
     socket.once('end', () => {
-        if (!conn.transaction) return next() // client gone
+        if (!connection.transaction) return next() // client gone
 
-        if (spamd_response.headers && spamd_response.headers.Tests) {
+        if (spamd_response.headers?.Tests) {
             spamd_response.tests = spamd_response.headers.Tests.replace(/\s/g, '');
         }
         if (spamd_response.tests === undefined) {
             // strip the 'tests' from the X-Spam-Status header
-            if (spamd_response.headers && spamd_response.headers.Status) {
+            if (spamd_response.headers?.Status) {
                 // SpamAssassin appears to have a bug that causes a space not to
                 // be added before autolearn= when the header line has been folded.
                 // So we modify the regexp here not to match autolearn onwards.
@@ -127,29 +123,28 @@ exports.hook_data_post = function (next, connection) {
 
         // do stuff with the results...
         txn.notes.spamassassin = spamd_response;
-        conn.results.add(plugin, {
+        connection.results.add(this, {
             time: (Date.now() - start)/1000,
             hits: spamd_response.hits,
             flag: spamd_response.flag,
         });
 
-        plugin.fixup_old_headers(txn);
-        plugin.do_header_updates(conn, spamd_response);
-        plugin.log_results(conn, spamd_response);
+        this.fixup_old_headers(txn);
+        this.do_header_updates(connection, spamd_response);
+        this.log_results(connection, spamd_response);
 
-        const exceeds_err = plugin.score_too_high(conn, spamd_response);
+        const exceeds_err = this.score_too_high(connection, spamd_response);
         if (exceeds_err) return next(DENY, exceeds_err);
 
-        plugin.munge_subject(conn, spamd_response.score);
+        this.munge_subject(connection, spamd_response.score);
 
         next();
     });
 }
 
 exports.fixup_old_headers = function (txn) {
-    const plugin = this;
-    const action = plugin.cfg.main.old_headers_action;
-    const headers = txn.notes.spamassassin.headers;
+    const action = this.cfg.main.old_headers_action;
+    const { headers } = txn.notes.spamassassin;
 
     let key;
     switch (action) {
@@ -178,29 +173,27 @@ exports.fixup_old_headers = function (txn) {
 }
 
 exports.munge_subject = function (conn, score) {
-    const plugin = this;
-    const munge = plugin.cfg.main.munge_subject_threshold;
+    const munge = this.cfg.main.munge_subject_threshold;
     if (!munge) return;
     if (parseFloat(score) < parseFloat(munge)) return;
 
     const subj = conn.transaction.header.get('Subject');
-    const subject_re = new RegExp(`^${utils.regexp_escape(plugin.cfg.main.subject_prefix)}`);
+    const subject_re = new RegExp(`^${utils.regexp_escape(this.cfg.main.subject_prefix)}`);
     if (subject_re.test(subj)) return;    // prevent double munge
 
     conn.transaction.remove_header('Subject');
-    conn.transaction.add_header('Subject', `${plugin.cfg.main.subject_prefix} ${subj}`);
+    conn.transaction.add_header('Subject', `${this.cfg.main.subject_prefix} ${subj}`);
 }
 
 exports.do_header_updates = function (conn, spamd_response) {
-    const plugin = this;
     if (spamd_response.flag === 'Yes') {
         // X-Spam-Flag is added by SpamAssassin
         conn.transaction.remove_header('precedence');
         conn.transaction.add_header('Precedence', 'junk');
     }
 
-    const modern = plugin.cfg.main.modern_status_syntax;
-    if ( !plugin.cfg.main.add_headers ) return;
+    const modern = this.cfg.main.modern_status_syntax;
+    if ( !this.cfg.main.add_headers ) return;
 
     for (const key in spamd_response.headers) {
         if (!key || key === '' || key === undefined) continue;
@@ -218,31 +211,27 @@ exports.do_header_updates = function (conn, spamd_response) {
 }
 
 exports.score_too_high = function (conn, spamd_response) {
-    const plugin = this;
-    const score = spamd_response.score;
+    const { score } = spamd_response;
     if (conn.relaying) {
-        const rmax = plugin.cfg.main.relay_reject_threshold;
+        const rmax = this.cfg.main.relay_reject_threshold;
         if (rmax && (score >= rmax)) {
             return "spam score exceeded relay threshold";
         }
     }
 
-    const max = plugin.cfg.main.reject_threshold;
-    if (max && (score >= max)) {
-        return "spam score exceeded threshold";
-    }
+    const max = this.cfg.main.reject_threshold;
+    if (max && (score >= max)) return "spam score exceeded threshold";
 
-    return false;
+    return '';
 }
 
 exports.get_spamd_username = function (conn) {
-    const plugin = this;
 
     let user = conn.transaction.notes.spamd_user;  // 1st priority
     if (user && user !== undefined) return user;
 
-    if (!plugin.cfg.main.spamd_user) return 'default';   // when not defined
-    user = plugin.cfg.main.spamd_user;
+    if (!this.cfg.main.spamd_user) return 'default';   // when not defined
+    user = this.cfg.main.spamd_user;
 
     // Enable per-user SA prefs
     if (user === 'first-recipient') {                // special cases
@@ -259,7 +248,6 @@ exports.get_spamd_username = function (conn) {
 }
 
 exports.get_spamd_headers = function (conn, username) {
-    const plugin = this;
     // http://svn.apache.org/repos/asf/spamassassin/trunk/spamd/PROTOCOL
     const headers = [
         'HEADERS SPAMC/1.4',
@@ -269,7 +257,7 @@ exports.get_spamd_headers = function (conn, username) {
         `X-Haraka-UUID: ${conn.transaction.uuid}`,
     ];
     if (conn.relaying) {
-        headers.push(`${plugin.cfg.main.spamc_auth_header}: true`);
+        headers.push(`${this.cfg.main.spamc_auth_header}: true`);
     }
 
     return headers;
@@ -335,8 +323,7 @@ exports.get_spamd_socket = function (next, conn, headers) {
 }
 
 exports.log_results = function (conn, spamd_response) {
-    const plugin = this;
-    const cfg = plugin.cfg.main;
+    const cfg = this.cfg.main;
     const reject_threshold = (conn.relaying) ? (cfg.relay_reject_threshold || cfg.reject_threshold) : cfg.reject_threshold;
 
     const human_text = `status=${spamd_response.flag}` +
@@ -345,49 +332,50 @@ exports.log_results = function (conn, spamd_response) {
               `, reject=${reject_threshold}` +
               `, tests="${spamd_response.tests}"`;
 
-    conn.transaction.results.add(plugin, {
+    conn.transaction.results.add(this, {
         human: human_text,
         status: spamd_response.flag, score: parseFloat(spamd_response.score),
         required: parseFloat(spamd_response.reqd), reject: reject_threshold, tests: spamd_response.tests,
         emit: true});
 }
 
-exports.should_skip = function (conn) {
-    const plugin = this;
+exports.should_skip = function (connection = {}) {
+    const { transaction } = connection;
+    if (!transaction) return true;
 
     // a message might be skipped for multiple reasons, store each in results
     let result = false;  // default
 
-    const max = plugin.cfg.main.max_size;
+    const max = this.cfg.main.max_size;
     if (max) {
-        const size = conn.transaction.data_bytes;
+        const size = connection.transaction.data_bytes;
         if (size > max) {
-            conn.transaction.results.add(plugin, { skip: `size ${utils.prettySize(size)} exceeds max: ${utils.prettySize(max)}`});
+            connection.transaction.results.add(this, { skip: `size ${utils.prettySize(size)} exceeds max: ${utils.prettySize(max)}`});
             result = true;
         }
     }
 
-    if (plugin.cfg.check.authenticated == false && conn.notes.auth_user) {
-        conn.transaction.results.add(plugin, { skip: 'authed'});
+    if (this.cfg.check.authenticated == false && connection.notes.auth_user) {
+        connection.transaction.results.add(this, { skip: 'authed'});
         result = true;
     }
 
-    if (plugin.cfg.check.relay == false && conn.relaying) {
-        conn.transaction.results.add(plugin, { skip: 'relay'});
+    if (this.cfg.check.relay == false && connection.relaying) {
+        connection.transaction.results.add(this, { skip: 'relay'});
         result = true;
     }
 
-    if (plugin.cfg.check.local_ip == false && conn.remote.is_local) {
-        conn.transaction.results.add(plugin, { skip: 'local_ip'});
+    if (this.cfg.check.local_ip == false && connection.remote.is_local) {
+        connection.transaction.results.add(this, { skip: 'local_ip'});
         result = true;
     }
 
-    if (plugin.cfg.check.private_ip == false && conn.remote.is_private) {
-        if (plugin.cfg.check.local_ip == true && conn.remote.is_local) {
+    if (this.cfg.check.private_ip == false && connection.remote.is_private) {
+        if (this.cfg.check.local_ip == true && connection.remote.is_local) {
             // local IPs are included in private IPs
         }
         else {
-            conn.transaction.results.add(plugin, { skip: 'private_ip'});
+            connection.transaction.results.add(this, { skip: 'private_ip'});
             result = true;
         }
     }

package/plugins/status.js

@@ -148,7 +148,7 @@ exports.queue_discard = function (file, cb) {
 }
 
 exports.queue_push = function (file, cb) {
-    const queue = this.outbound.temp_fail_queue.queue;
+    const { queue } = this.outbound.temp_fail_queue;
 
     for (let i = 0; i < queue.length; i++) {
         if (queue[i].id !== file) continue;
@@ -214,10 +214,9 @@ exports.call_master = (cmd, cb) => {
 }
 
 exports.call_workers = function (cmd, cb) {
-    const self = this;
 
     async.map(server.cluster.workers, (w, done) => {
-        self.call_worker(w, cmd, done);
+        this.call_worker(w, cmd, done);
     }, cb);
 }
 

package/plugins/tarpit.js

@@ -8,30 +8,27 @@ let hooks_to_delay = [
 
 exports.register = function () {
     // Register tarpit function last
-    const plugin = this;
 
-    const cfg = plugin.config.get('tarpit.ini');
-    if (cfg && cfg.main.hooks_to_delay) {
+    const cfg = this.config.get('tarpit.ini');
+    if (cfg?.main.hooks_to_delay) {
         hooks_to_delay = cfg.main.hooks_to_delay.split(/[\s,;]+/);
     }
 
-    for (let i=0; i < hooks_to_delay.length; i++) {
-        const hook = hooks_to_delay[i];
-        plugin.register_hook(hook, 'tarpit');
+    for (const hook of hooks_to_delay) {
+        this.register_hook(hook, 'tarpit');
     }
 }
 
 exports.tarpit = function (next, connection) {
-    const plugin = this;
+    const { transaction } = connection;
+    if (!transaction) return next();
 
     let delay = connection.notes.tarpit;
 
-    if (!delay && connection.transaction) {
-        delay = connection.transaction.notes.tarpit;
-    }
+    if (!delay) delay = transaction.notes.tarpit;
 
     if (!delay) return next();
 
-    connection.loginfo(plugin, `tarpitting response for ${delay}s`);
+    connection.loginfo(this, `tarpitting response for ${delay}s`);
     setTimeout(() => next(),  delay * 1000);
 }

package/plugins/tls.js

@@ -21,18 +21,17 @@ exports.shutdown = () => {
 }
 
 exports.advertise_starttls = function (next, connection) {
-    const plugin = this;
 
     // if no TLS setup incomplete/invalid, don't advertise
     if (!tls_socket.tls_valid) {
-        plugin.logerror('no valid TLS config');
+        this.logerror('no valid TLS config');
         return next();
     }
 
     /* Caution: do not advertise STARTTLS if already TLS upgraded */
     if (connection.tls.enabled) return next();
 
-    if (plugin.net_utils.ip_in_list(tls_socket.cfg.no_tls_hosts, connection.remote.ip)) {
+    if (this.net_utils.ip_in_list(tls_socket.cfg.no_tls_hosts, connection.remote.ip)) {
         return next();
     }
 
@@ -52,20 +51,19 @@ exports.advertise_starttls = function (next, connection) {
         return enable_tls();
     }
 
-    const redis = server.notes.redis;
+    const { redis } = server.notes;
     const dbkey = `no_tls|${connection.remote.ip}`;
 
-    redis.get(dbkey, (err, dbr) => {
-        if (err) {
-            connection.results.add(plugin, {err});
-            return enable_tls();
-        }
-
-        if (!dbr) return enable_tls();
-
-        connection.results.add(plugin, { msg: 'no_tls'});
-        return next(CONT, 'STARTTLS disabled because previous attempt failed')
-    });
+    redis.get(dbkey)
+        .then(dbr => {
+            if (!dbr) return enable_tls();
+            connection.results.add(this, { msg: 'no_tls'});
+            next(CONT, 'STARTTLS disabled because previous attempt failed')
+        })
+        .catch(err => {
+            connection.results.add(this, {err});
+            enable_tls();
+        })
 }
 
 exports.set_notls = function (connection) {
@@ -138,7 +136,6 @@ exports.hook_disconnect = (next, connection) => {
 }
 
 exports.emit_upgrade_msg = function (conn, verified, verifyErr, cert, cipher) {
-    const plugin = this;
     let msg = 'secured:';
     if (cipher) {
         msg += ` cipher=${cipher.name} version=${cipher.version}`;
@@ -154,6 +151,6 @@ exports.emit_upgrade_msg = function (conn, verified, verifyErr, cert, cipher) {
         if (cert.fingerprint) msg += ` fingerprint=${cert.fingerprint}`;
     }
 
-    conn.loginfo(plugin,  msg);
+    conn.loginfo(this,  msg);
     return msg;
 }

package/plugins/toobusy.js

@@ -4,26 +4,24 @@ let toobusy;
 let was_busy = false;
 
 exports.register = function () {
-    const plugin = this;
 
     try {
         toobusy = require('toobusy-js');
     }
     catch (e) {
-        plugin.logerror(e);
-        plugin.logerror("try: 'npm install -g toobusy-js'");
+        this.logerror(e);
+        this.logerror("try: 'npm install -g toobusy-js'");
         return;
     }
 
-    plugin.loadConfig();
+    this.loadConfig();
 
-    plugin.register_hook('connect', 'check_busy', -100);
+    this.register_hook('connect', 'check_busy', -100);
 }
 
 exports.loadConfig = function () {
-    const plugin = this;
-    let maxLag = plugin.config.get('toobusy.maxlag','value', () => {
-        plugin.loadConfig();
+    let maxLag = this.config.get('toobusy.maxlag','value', () => {
+        this.loadConfig();
     });
 
     maxLag = parseInt(maxLag);

package/plugins/xclient.js

@@ -11,9 +11,8 @@ exports.register = function () {
 }
 
 exports.load_xclient_hosts = function () {
-    const self = this;
     const cfg = this.config.get('xclient.hosts', 'list', () => {
-        self.load_xclient_hosts();
+        this.load_xclient_hosts();
     });
     const ah = {};
     for (const i in cfg) {
@@ -23,10 +22,7 @@ exports.load_xclient_hosts = function () {
 }
 
 function xclient_allowed (ip) {
-    if (ip === '127.0.0.1' || ip === '::1' || allowed_hosts[ip]) {
-        return true;
-    }
-    return false;
+    return !!(ip === '127.0.0.1' || ip === '::1' || allowed_hosts[ip]);
 }
 
 exports.hook_capabilities = (next, connection) => {
@@ -37,17 +33,14 @@ exports.hook_capabilities = (next, connection) => {
 }
 
 exports.hook_unrecognized_command = function (next, connection, params) {
-    if (params[0] !== 'XCLIENT') {
-        return next();
-    }
+    if (params[0] !== 'XCLIENT') return next();
 
     // XCLIENT is not allowed after transaction start
-    if (connection.transaction) {
-        return next(DENY,
-            DSN.proto_unspecified('Mail transaction in progress', 503));
+    if (connection?.transaction) {
+        return next(DENY, DSN.proto_unspecified('Mail transaction in progress', 503));
     }
 
-    if (!(xclient_allowed(connection.remote.ip))) {
+    if (!(xclient_allowed(connection?.remote?.ip))) {
         return next(DENY, DSN.proto_unspecified('Not authorized', 550));
     }
 
@@ -55,8 +48,8 @@ exports.hook_unrecognized_command = function (next, connection, params) {
     // Process arguments
     const args = (new String(params[1])).toLowerCase().split(/ /);
     const xclient = {};
-    for (let a=0; a < args.length; a++) {
-        const match = /^([^=]+)=([^ ]+)/.exec(args[a]);
+    for (const arg of args) {
+        const match = /^([^=]+)=([^ ]+)/.exec(arg);
         if (match) {
             connection.logdebug(this, `found key=${match[1]} value=${match[2]}`);
             switch (match[1]) {
@@ -94,18 +87,17 @@ exports.hook_unrecognized_command = function (next, connection, params) {
                     }
                     break;
                 default:
-                    connection.logwarn(this, `unknown argument: ${args[a]}`);
+                    connection.logwarn(this, `unknown argument: ${arg}`);
             }
         }
         else {
-            connection.logwarn(this, `unknown argument: ${args[a]}`);
+            connection.logwarn(this, `unknown argument: ${arg}`);
         }
     }
 
     // Abort if we don't have a valid IP address
     if (!xclient.addr) {
-        return next(DENY,
-            DSN.proto_invalid_cmd_args('No valid IP address found', 501));
+        return next(DENY, DSN.proto_invalid_cmd_args('No valid IP address found', 501));
     }
 
     // Apply changes
@@ -125,10 +117,7 @@ exports.hook_unrecognized_command = function (next, connection, params) {
     }
     connection.esmtp = (xclient.proto === 'esmtp');
     connection.xclient = true;
-    if (!xclient.name) {
-        return next(NEXT_HOOK, 'lookup_rdns');
-    }
-    else {
-        return next(NEXT_HOOK, 'connect');
-    }
+    if (!xclient.name) return next(NEXT_HOOK, 'lookup_rdns');
+
+    return next(NEXT_HOOK, 'connect');
 }