Haraka 2.8.28 → 3.0.1

package/plugins/helo.checks.js

@@ -19,42 +19,39 @@ const checks = [
 ];
 
 exports.register = function () {
-    const plugin = this;
-    plugin.load_helo_checks_ini();
+    this.load_helo_checks_ini();
 
-    if (plugin.cfg.check.proto_mismatch) {
+    if (this.cfg.check.proto_mismatch) {
         // NOTE: these *must* run before init
-        plugin.register_hook('helo', 'proto_mismatch_smtp');
-        plugin.register_hook('ehlo', 'proto_mismatch_esmtp');
+        this.register_hook('helo', 'proto_mismatch_smtp');
+        this.register_hook('ehlo', 'proto_mismatch_esmtp');
     }
 
     // Always run init
-    plugin.register_hook('helo', 'init');
-    plugin.register_hook('ehlo', 'init');
+    this.register_hook('helo', 'init');
+    this.register_hook('ehlo', 'init');
 
-    for (let i=0; i < checks.length; i++) {
-        const hook = checks[i];
-        if (!plugin.cfg.check[hook]) continue; // disabled in config
-        plugin.register_hook('helo', hook);
-        plugin.register_hook('ehlo', hook);
+    for (const c in checks) {
+        if (!this.cfg.check[c]) continue; // disabled in config
+        this.register_hook('helo', c);
+        this.register_hook('ehlo', c);
     }
 
     // Always emit a log entry
-    plugin.register_hook('helo', 'emit_log');
-    plugin.register_hook('ehlo', 'emit_log');
+    this.register_hook('helo', 'emit_log');
+    this.register_hook('ehlo', 'emit_log');
 
-    if (plugin.cfg.check.match_re) {
+    if (this.cfg.check.match_re) {
         const load_re_file = () => {
-            const regex_list = utils.valid_regexes(plugin.config.get('helo.checks.regexps', 'list', load_re_file));
+            const regex_list = utils.valid_regexes(this.config.get('helo.checks.regexps', 'list', load_re_file));
             // pre-compile the regexes
-            plugin.cfg.list_re = new RegExp(`^(${regex_list.join('|')})$`, 'i');
+            this.cfg.list_re = new RegExp(`^(${regex_list.join('|')})$`, 'i');
         };
         load_re_file();
     }
 }
 
 exports.load_helo_checks_ini = function () {
-    const plugin = this;
 
     const booleans = [
         '+skip.private_ip',
@@ -70,63 +67,53 @@ exports.load_helo_checks_ini = function () {
         booleans.push(`-reject.${c}`);
     });
 
-    plugin.cfg = plugin.config.get('helo.checks.ini', { booleans },
+    this.cfg = this.config.get('helo.checks.ini', { booleans },
         () => {
-            plugin.load_helo_checks_ini();
+            this.load_helo_checks_ini();
         });
 
     // backwards compatible with old config file
-    if (plugin.cfg.check_no_dot !== undefined) {
-        plugin.cfg.check.valid_hostname = !!plugin.cfg.check_no_dot;
+    if (this.cfg.check_no_dot !== undefined) {
+        this.cfg.check.valid_hostname = !!this.cfg.check_no_dot;
     }
-    if (plugin.cfg.check_dynamic !== undefined) {
-        plugin.cfg.check.dynamic = !!plugin.cfg.check_dynamic;
+    if (this.cfg.check_dynamic !== undefined) {
+        this.cfg.check.dynamic = !!this.cfg.check_dynamic;
     }
-    if (plugin.cfg.check_raw_ip !== undefined) {
-        plugin.cfg.check.bare_ip = !!plugin.cfg.check_raw_ip;
+    if (this.cfg.check_raw_ip !== undefined) {
+        this.cfg.check.bare_ip = !!this.cfg.check_raw_ip;
     }
 
     // non-default setting, so apply their localized setting
-    if (plugin.cfg.check.mismatch !== undefined && !plugin.cfg.check.mismatch) {
-        plugin.logerror('deprecated setting mismatch renamed to host_mismatch');
-        plugin.cfg.check.host_mismatch = plugin.cfg.check.mismatch;
+    if (this.cfg.check.mismatch !== undefined && !this.cfg.check.mismatch) {
+        this.logerror('deprecated setting mismatch renamed to host_mismatch');
+        this.cfg.check.host_mismatch = this.cfg.check.mismatch;
     }
-    if (plugin.cfg.reject.mismatch !== undefined && plugin.cfg.reject.mismatch) {
-        plugin.logerror('deprecated setting mismatch renamed to host_mismatch');
-        plugin.cfg.reject.host_mismatch = plugin.cfg.reject.mismatch;
+    if (this.cfg.reject.mismatch !== undefined && this.cfg.reject.mismatch) {
+        this.logerror('deprecated setting mismatch renamed to host_mismatch');
+        this.cfg.reject.host_mismatch = this.cfg.reject.mismatch;
     }
 }
 
 exports.init = function (next, connection, helo) {
-    const plugin = this;
 
     const hc = connection.results.get('helo.checks');
     if (!hc) {     // first HELO result
-        connection.results.add(plugin, {helo_host: helo});
+        connection.results.add(this, {helo_host: helo});
         return next();
     }
 
-    // we've been here before
-    connection.results.add(plugin, {multi: true});
-
-    return next();
+    next();
 }
 
 exports.should_skip = function (connection, test_name) {
-    const plugin = this;
-
-    const hc = connection.results.get('helo.checks');
-    if (hc && hc.multi && test_name !== 'host_mismatch' && test_name !== 'proto_mismatch') {
-        return true;
-    }
 
-    if (plugin.cfg.skip.relaying && connection.relaying) {
-        connection.results.add(plugin, {skip: `${test_name}(relay)`});
+    if (this.cfg.skip.relaying && connection.relaying) {
+        connection.results.add(this, {skip: `${test_name}(relay)`});
         return true;
     }
 
-    if (plugin.cfg.skip.private_ip && connection.remote.is_private) {
-        connection.results.add(plugin, {skip: `${test_name}(private)`});
+    if (this.cfg.skip.private_ip && connection.remote.is_private) {
+        connection.results.add(this, {skip: `${test_name}(private)`});
         return true;
     }
 
@@ -134,42 +121,39 @@ exports.should_skip = function (connection, test_name) {
 }
 
 exports.host_mismatch = function (next, connection, helo) {
-    const plugin = this;
-
-    if (plugin.should_skip(connection, 'host_mismatch')) { return next(); }
+    if (this.should_skip(connection, 'host_mismatch')) return next();
 
     const prev_helo = connection.results.get('helo.checks').helo_host;
     if (!prev_helo) {
-        connection.results.add(plugin, {skip: 'host_mismatch(1st)'});
+        connection.results.add(this, {skip: 'host_mismatch(1st)'});
         connection.notes.prev_helo = helo;
         return next();
     }
 
     if (prev_helo === helo) {
-        connection.results.add(plugin, {pass: 'host_mismatch'});
+        connection.results.add(this, {pass: 'host_mismatch'});
         return next();
     }
 
     const msg = `host_mismatch(${prev_helo} / ${helo})`;
-    connection.results.add(plugin, {fail: msg});
-    if (!plugin.cfg.reject.host_mismatch) return next();
+    connection.results.add(this, {fail: msg});
+    if (!this.cfg.reject.host_mismatch) return next();
 
-    return next(DENY, `HELO host ${msg}`);
+    next(DENY, `HELO host ${msg}`);
 }
 
 exports.valid_hostname = function (next, connection, helo) {
-    const plugin = this;
 
-    if (plugin.should_skip(connection, 'valid_hostname')) { return next(); }
+    if (this.should_skip(connection, 'valid_hostname')) return next();
 
     if (net_utils.is_ip_literal(helo)) {
-        connection.results.add(plugin, {skip: 'valid_hostname(literal)'});
+        connection.results.add(this, {skip: 'valid_hostname(literal)'});
         return next();
     }
 
     if (!/\./.test(helo)) {
-        connection.results.add(plugin, {fail: 'valid_hostname(no_dot)'});
-        if (plugin.cfg.reject.valid_hostname) {
+        connection.results.add(this, {fail: 'valid_hostname(no_dot)'});
+        if (this.cfg.reject.valid_hostname) {
             return next(DENY, 'HELO host must be a FQDN or address literal (RFC 5321 2.3.5)');
         }
         return next();
@@ -184,290 +168,281 @@ exports.valid_hostname = function (next, connection, helo) {
         if (tld === 'local' || tld === 'lan' || tld === 'corp' || excludes.includes(`.${tld}`)) {
             return next();
         }
-        connection.results.add(plugin, {fail: 'valid_hostname'});
-        if (plugin.cfg.reject.valid_hostname) {
+        connection.results.add(this, {fail: 'valid_hostname'});
+        if (this.cfg.reject.valid_hostname) {
             return next(DENY, "HELO host name invalid");
         }
         return next();
     }
 
-    connection.results.add(plugin, {pass: 'valid_hostname'});
-    return next();
+    connection.results.add(this, {pass: 'valid_hostname'});
+    next();
 }
 
 exports.match_re = function (next, connection, helo) {
-    const plugin = this;
 
-    if (plugin.should_skip(connection, 'match_re')) { return next(); }
+    if (this.should_skip(connection, 'match_re')) return next();
 
-    if (plugin.cfg.list_re && plugin.cfg.list_re.test(helo)) {
-        connection.results.add(plugin, {fail: 'match_re'});
-        if (plugin.cfg.reject.match_re) {
+    if (this.cfg.list_re?.test(helo)) {
+        connection.results.add(this, {fail: 'match_re'});
+        if (this.cfg.reject.match_re) {
             return next(DENY, "That HELO not allowed here");
         }
         return next();
     }
-    connection.results.add(plugin, {pass: 'match_re'});
-    return next();
+    connection.results.add(this, {pass: 'match_re'});
+    next();
 }
 
 exports.rdns_match = function (next, connection, helo) {
-    const plugin = this;
 
-    if (plugin.should_skip(connection, 'rdns_match')) { return next(); }
+    if (this.should_skip(connection, 'rdns_match')) return next();
 
     if (!helo) {
-        connection.results.add(plugin, {fail: 'rdns_match(empty)'});
+        connection.results.add(this, {fail: 'rdns_match(empty)'});
         return next();
     }
 
     if (net_utils.is_ip_literal(helo)) {
-        connection.results.add(plugin, {fail: 'rdns_match(literal)'});
+        connection.results.add(this, {fail: 'rdns_match(literal)'});
         return next();
     }
 
     const r_host = connection.remote.host;
     if (r_host && helo === r_host) {
-        connection.results.add(plugin, {pass: 'rdns_match'});
+        connection.results.add(this, {pass: 'rdns_match'});
         return next();
     }
 
     if (tlds.get_organizational_domain(r_host) ===
         tlds.get_organizational_domain(helo)) {
-        connection.results.add(plugin, {pass: 'rdns_match(org_dom)'});
+        connection.results.add(this, {pass: 'rdns_match(org_dom)'});
         return next();
     }
 
-    connection.results.add(plugin, {fail: 'rdns_match'});
-    if (plugin.cfg.reject.rdns_match) {
+    connection.results.add(this, {fail: 'rdns_match'});
+    if (this.cfg.reject.rdns_match) {
         return next(DENY, 'HELO host does not match rDNS');
     }
-    return next();
+    next();
 }
 
 exports.bare_ip = function (next, connection, helo) {
-    const plugin = this;
 
-    if (plugin.should_skip(connection, 'bare_ip')) { return next(); }
+    if (this.should_skip(connection, 'bare_ip')) return next();
 
     // RFC 2821, 4.1.1.1  Address literals must be in brackets
     // RAW IPs must be formatted: "[1.2.3.4]" not "1.2.3.4" in HELO
     if (net_utils.get_ipany_re('^(?:IPv6:)?','$','').test(helo)) {
-        connection.results.add(plugin, {fail: 'bare_ip(invalid literal)'});
-        if (plugin.cfg.reject.bare_ip) {
+        connection.results.add(this, {fail: 'bare_ip(invalid literal)'});
+        if (this.cfg.reject.bare_ip) {
             return next(DENY, "Invalid address format in HELO");
         }
         return next();
     }
 
-    connection.results.add(plugin, {pass: 'bare_ip'});
-    return next();
+    connection.results.add(this, {pass: 'bare_ip'});
+    next();
 }
 
 exports.dynamic = function (next, connection, helo) {
-    const plugin = this;
 
-    if (plugin.should_skip(connection, 'dynamic')) { return next(); }
+    if (this.should_skip(connection, 'dynamic')) return next();
 
     // Skip if no dots or an IP literal or address
     if (!/\./.test(helo)) {
-        connection.results.add(plugin, {skip: 'dynamic(no dots)'});
+        connection.results.add(this, {skip: 'dynamic(no dots)'});
         return next();
     }
 
     if (net_utils.get_ipany_re('^\\[?(?:IPv6:)?','\\]?$','').test(helo)) {
-        connection.results.add(plugin, {skip: 'dynamic(literal)'});
+        connection.results.add(this, {skip: 'dynamic(literal)'});
         return next();
     }
 
     if (net_utils.is_ip_in_str(connection.remote.ip, helo)) {
-        connection.results.add(plugin, {fail: 'dynamic'});
-        if (plugin.cfg.reject.dynamic) {
+        connection.results.add(this, {fail: 'dynamic'});
+        if (this.cfg.reject.dynamic) {
             return next(DENY, 'HELO is dynamic');
         }
         return next();
     }
 
-    connection.results.add(plugin, {pass: 'dynamic'});
-    return next();
+    connection.results.add(this, {pass: 'dynamic'});
+    next();
 }
 
 exports.big_company = function (next, connection, helo) {
-    const plugin = this;
 
-    if (plugin.should_skip(connection, 'big_company')) { return next(); }
+    if (this.should_skip(connection, 'big_company')) return next();
 
     if (net_utils.is_ip_literal(helo)) {
-        connection.results.add(plugin, {skip: 'big_co(literal)'});
+        connection.results.add(this, {skip: 'big_co(literal)'});
         return next();
     }
 
-    if (!plugin.cfg.bigco) {
-        connection.results.add(plugin, {err: 'big_co(config missing)'});
+    if (!this.cfg.bigco) {
+        connection.results.add(this, {err: 'big_co(config missing)'});
         return next();
     }
 
-    if (!plugin.cfg.bigco[helo]) {
-        connection.results.add(plugin, {pass: 'big_co(not)'});
+    if (!this.cfg.bigco[helo]) {
+        connection.results.add(this, {pass: 'big_co(not)'});
         return next();
     }
 
     const rdns = connection.remote.host;
     if (!rdns || rdns === 'Unknown' || rdns === 'DNSERROR') {
-        connection.results.add(plugin, {fail: 'big_co(rDNS)'});
-        if (plugin.cfg.reject.big_company) {
+        connection.results.add(this, {fail: 'big_co(rDNS)'});
+        if (this.cfg.reject.big_company) {
             return next(DENY, "Big company w/o rDNS? Unlikely.");
         }
         return next();
     }
 
-    const allowed_rdns = plugin.cfg.bigco[helo].split(/,/);
-    for (let i=0; i < allowed_rdns.length; i++) {
-        const re = new RegExp(`${allowed_rdns[i].replace(/\./g, '\\.')}$`);
+    const allowed_rdns = this.cfg.bigco[helo].split(/,/);
+    for (const allow of allowed_rdns) {
+        const re = new RegExp(`${allow.replace(/\./g, '\\.')}$`);
         if (re.test(rdns)) {
-            connection.results.add(plugin, {pass: 'big_co'});
+            connection.results.add(this, {pass: 'big_co'});
             return next();
         }
     }
 
-    connection.results.add(plugin, {fail: 'big_co'});
-    if (plugin.cfg.reject.big_company) {
+    connection.results.add(this, {fail: 'big_co'});
+    if (this.cfg.reject.big_company) {
         return next(DENY, "You are not who you say you are");
     }
-    return next();
+    next();
 }
 
 exports.literal_mismatch = function (next, connection, helo) {
-    const plugin = this;
 
-    if (plugin.should_skip(connection, 'literal_mismatch')) { return next(); }
+    if (this.should_skip(connection, 'literal_mismatch')) return next();
 
     const literal = net_utils.get_ipany_re('^\\[(?:IPv6:)?','\\]$','').exec(helo);
     if (!literal) {
-        connection.results.add(plugin, {pass: 'literal_mismatch'});
+        connection.results.add(this, {pass: 'literal_mismatch'});
         return next();
     }
 
-    const lmm_mode = parseInt(plugin.cfg.check.literal_mismatch, 10);
+    const lmm_mode = parseInt(this.cfg.check.literal_mismatch, 10);
     const helo_ip = literal[1];
     if (lmm_mode > 2 && net_utils.is_private_ip(helo_ip)) {
-        connection.results.add(plugin, {pass: 'literal_mismatch(private)'});
+        connection.results.add(this, {pass: 'literal_mismatch(private)'});
         return next();
     }
 
     if (lmm_mode > 1) {
         if (net_utils.same_ipv4_network(connection.remote.ip, [helo_ip])) {
-            connection.results.add(plugin, {pass: 'literal_mismatch'});
+            connection.results.add(this, {pass: 'literal_mismatch'});
             return next();
         }
 
-        connection.results.add(plugin, {fail: 'literal_mismatch'});
-        if (plugin.cfg.reject.literal_mismatch) {
+        connection.results.add(this, {fail: 'literal_mismatch'});
+        if (this.cfg.reject.literal_mismatch) {
             return next(DENY, 'HELO IP literal not in the same /24 as your IP address');
         }
         return next();
     }
 
     if (helo_ip === connection.remote.ip) {
-        connection.results.add(plugin, {pass: 'literal_mismatch'});
+        connection.results.add(this, {pass: 'literal_mismatch'});
         return next();
     }
 
-    connection.results.add(plugin, {fail: 'literal_mismatch'});
-    if (plugin.cfg.reject.literal_mismatch) {
+    connection.results.add(this, {fail: 'literal_mismatch'});
+    if (this.cfg.reject.literal_mismatch) {
         return next(DENY, 'HELO IP literal does not match your IP address');
     }
-    return next();
+    next();
 }
 
 exports.forward_dns = function (next, connection, helo) {
-    const plugin = this;
 
-    if (plugin.should_skip(connection, 'forward_dns')) { return next(); }
-    if (!plugin.cfg.check.valid_hostname) {
-        connection.results.add(plugin, {err: 'forward_dns(valid_hostname disabled)'});
+    if (this.should_skip(connection, 'forward_dns')) return next();
+    if (!this.cfg.check.valid_hostname) {
+        connection.results.add(this, {err: 'forward_dns(valid_hostname disabled)'});
         return next();
     }
 
     if (net_utils.is_ip_literal(helo)) {
-        connection.results.add(plugin, {skip: 'forward_dns(literal)'});
+        connection.results.add(this, {skip: 'forward_dns(literal)'});
         return next();
     }
 
     if (!connection.results.has('helo.checks', 'pass', /^valid_hostname/)) {
-        connection.results.add(plugin, {fail: 'forward_dns(invalid_hostname)'});
-        if (plugin.cfg.reject.forward_dns) {
+        connection.results.add(this, {fail: 'forward_dns(invalid_hostname)'});
+        if (this.cfg.reject.forward_dns) {
             return next(DENY, "Invalid HELO host cannot achieve forward DNS match");
         }
         return next();
     }
 
-    const cb = (err, ips) => {
-        if (err) {
-            if (err.code === dns.NOTFOUND || err.code === dns.NODATA || err.code === dns.SERVFAIL) {
-                connection.results.add(plugin, {fail: `forward_dns(${err.code})`});
+    this.get_a_records(helo)
+        .then(ips => {
+
+            if (!ips) {
+                connection.results.add(this, {err: 'forward_dns, no ips!'});
                 return next();
             }
-            if (err.code === dns.TIMEOUT && plugin.cfg.reject.forward_dns) {
-                connection.results.add(plugin, {fail: `forward_dns(${err.code})`});
-                return next(DENYSOFT, "DNS timeout resolving your HELO hostname");
-            }
-            connection.results.add(plugin, {err: `forward_dns(${err})`, emit_log_level: 'warn'});
-            return next();
-        }
-
-        if (!ips) {
-            connection.results.add(plugin, {err: 'forward_dns, no ips!'});
-            return next();
-        }
-        connection.results.add(plugin, {ips});
+            connection.results.add(this, {ips});
 
-        if (ips.includes(connection.remote.ip)) {
-            connection.results.add(plugin, {pass: 'forward_dns'});
-            return next();
-        }
-
-        // some valid hosts (facebook.com, hotmail.com, ) use a generic HELO
-        // hostname that resolves but doesn't contain the IP that is
-        // connecting. If their rDNS passed, and their HELO hostname is in
-        // the same domain, consider it close enough.
-        if (connection.results.has('helo.checks', 'pass', /^rdns_match/)) {
-            const helo_od = tlds.get_organizational_domain(helo);
-            const rdns_od = tlds.get_organizational_domain(connection.remote.host);
-            if (helo_od && helo_od === rdns_od) {
-                connection.results.add(plugin, {pass: 'forward_dns(domain)'});
+            if (ips.includes(connection.remote.ip)) {
+                connection.results.add(this, {pass: 'forward_dns'});
                 return next();
             }
-            connection.results.add(plugin, {msg: `od miss: ${helo_od}, ${rdns_od}`});
-        }
 
-        connection.results.add(plugin, {fail: 'forward_dns(no IP match)'});
-        if (plugin.cfg.reject.forward_dns) {
-            return next(DENY, "HELO host has no forward DNS match");
-        }
-        return next();
-    };
+            // some valid hosts (facebook.com, hotmail.com) use a generic HELO
+            // hostname that resolves but doesn't contain the IP that is
+            // connecting. If their rDNS passed, and their HELO hostname is in
+            // the same domain, consider it close enough.
+            if (connection.results.has('helo.checks', 'pass', /^rdns_match/)) {
+                const helo_od = tlds.get_organizational_domain(helo);
+                const rdns_od = tlds.get_organizational_domain(connection.remote.host);
+                if (helo_od && helo_od === rdns_od) {
+                    connection.results.add(this, {pass: 'forward_dns(domain)'});
+                    return next();
+                }
+                connection.results.add(this, {msg: `od miss: ${helo_od}, ${rdns_od}`});
+            }
 
-    plugin.get_a_records(helo, cb);
+            connection.results.add(this, {fail: 'forward_dns(no IP match)'});
+            if (this.cfg.reject.forward_dns) {
+                return next(DENY, "HELO host has no forward DNS match");
+            }
+            next();
+        })
+        .catch(err => {
+            if (err.code === dns.NOTFOUND || err.code === dns.NODATA || err.code === dns.SERVFAIL) {
+                connection.results.add(this, {fail: `forward_dns(${err.code})`});
+                return next();
+            }
+            if (err.code === dns.TIMEOUT && this.cfg.reject.forward_dns) {
+                connection.results.add(this, {fail: `forward_dns(${err.code})`});
+                return next(DENYSOFT, "DNS timeout resolving your HELO hostname");
+            }
+            connection.results.add(this, {err: `forward_dns(${err})`, emit_log_level: 'warn'});
+            next();
+        })
 }
 
 exports.proto_mismatch = function (next, connection, helo, proto) {
-    const plugin = this;
 
-    if (plugin.should_skip(connection, 'proto_mismatch')) { return next(); }
+    if (this.should_skip(connection, 'proto_mismatch')) return next();
 
     const r = connection.results.get('helo.checks');
-    if (!r || (r && !r.helo_host)) { return next(); }
+    if (!r || (r && !r.helo_host)) return next();
 
     if ((connection.esmtp && proto === 'smtp') ||
         (!connection.esmtp && proto === 'esmtp')) {
-        connection.results.add(plugin, {fail: `proto_mismatch(${proto})`});
-        if (plugin.cfg.reject.proto_mismatch) {
+        connection.results.add(this, {fail: `proto_mismatch(${proto})`});
+        if (this.cfg.reject.proto_mismatch) {
             return next(DENY, `${proto === 'smtp' ? 'HELO' : 'EHLO'} protocol mismatch`);
         }
     }
 
-    return next();
+    next();
 }
 
 exports.proto_mismatch_smtp = function (next, connection, helo) {
@@ -479,7 +454,6 @@ exports.proto_mismatch_esmtp = function (next, connection, helo) {
 }
 
 exports.emit_log = function (next, connection, helo) {
-    const plugin = this;
     // Spits out an INFO log entry. Default looks like this:
     // [helo.checks] helo_host: [182.212.17.35], fail:big_co(rDNS) rdns_match(literal), pass:valid_hostname, match_re, bare_ip, literal_mismatch, mismatch, skip:dynamic(literal), valid_hostname(literal)
     //
@@ -496,18 +470,17 @@ exports.emit_log = function (next, connection, helo) {
     // [UUID] [helo.checks] fail:rdns_match
     // [UUID] [helo.checks]
     // [UUID] [helo.checks] fail:dynamic
-    connection.loginfo(plugin, connection.results.collate(plugin));
-    return next();
+    connection.loginfo(this, connection.results.collate(this));
+    next();
 }
 
-exports.get_a_records = function (host, cb) {
-    const plugin = this;
+exports.get_a_records = async function (host) {
 
     if (!/\./.test(host)) {
         // a single label is not a host name
         const e = new Error("invalid hostname");
         e.code = dns.NOTFOUND;
-        return cb(e);
+        throw e;
     }
 
     // Set-up timer
@@ -516,19 +489,20 @@ exports.get_a_records = function (host, cb) {
         timed_out = true;
         const err = new Error(`timeout resolving: ${host}`);
         err.code = dns.TIMEOUT;
-        plugin.logerror(err);
-        return cb(err);
-    }, (plugin.cfg.main.dns_timeout || 30) * 1000);
+        this.logerror(err);
+        throw err;
+    }, (this.cfg.main.dns_timeout || 30) * 1000);
 
     // fully qualify, to ignore any search options in /etc/resolv.conf
-    if (!/\.$/.test(host)) { host = `${host}.`; }
+    if (!/\.$/.test(host)) host = `${host}.`;
 
     // do the queries
-    net_utils.get_ips_by_host(host, (errs, ips) => {
-        // results is now equals to: {queryA: 1, queryAAAA: 2}
-        if (timed_out) { return; }
-        if (timer) { clearTimeout(timer); }
-        let err = '';
+    let ips
+    let err = '';
+    try {
+        ips = await net_utils.get_ips_by_host(host)
+    }
+    catch (errs) {
         for (const error of errs) {
             switch (error.code) {
                 case dns.NODATA:
@@ -539,9 +513,13 @@ exports.get_a_records = function (host, cb) {
                     err = `${err}, ${error.message}`;
             }
         }
-        if (!ips.length && err) { return cb(err, ips); }
-        // plugin.logdebug(plugin, host + ' => ' + ips);
-        // return the DNS results
-        return cb(null, ips);
-    });
-}
+    }
+
+    // results is now equals to: {queryA: 1, queryAAAA: 2}
+    if (timed_out) return;
+    if (timer) clearTimeout(timer);
+    if (!ips.length && err) throw err
+    // this.logdebug(this, host + ' => ' + ips);
+    // return the DNS results
+    return ips;
+};