Haraka 3.1.1 → 3.1.2

package/outbound/config.js

@@ -1,46 +1,51 @@
-'use strict';
+'use strict'
 
-const config = require('haraka-config');
-const logger = require('../logger');
+const config = require('haraka-config')
+const logger = require('../logger')
 
 exports.name = 'outbound/config'
 
-function load_config () {
-    const cfg = exports.cfg = config.get('outbound.ini', {
-        booleans: [
-            '-disabled',
-            '-always_split',
-            '+enable_tls',
-            '-local_mx_ok',
-        ],
-    }, () => {
-        load_config();
-    }).main;
+function load_config() {
+    const cfg = (exports.cfg = config.get(
+        'outbound.ini',
+        {
+            booleans: ['-disabled', '-always_split', '+enable_tls', '-local_mx_ok'],
+        },
+        () => {
+            load_config()
+        },
+    ).main)
+
+    if (!cfg.inet_prefer) cfg.inet_prefer = 'default'
+    if (!cfg.inet_prefer.match(/^(v4|v6|default)$/)) {
+        logger.warn(exports, `inet_prefer is set to an invalid value: ${cfg.inet_prefer}`)
+        cfg.inet_prefer = 'default'
+    }
 
     // legacy config file support. Remove in Haraka 4.0
     if (!cfg.disabled && config.get('outbound.disabled')) {
-        cfg.disabled = true;
+        cfg.disabled = true
     }
     if (!cfg.enable_tls && config.get('outbound.enable_tls')) {
-        cfg.enable_tls = true;
+        cfg.enable_tls = true
     }
     if (!cfg.temp_fail_intervals) {
-        cfg.temp_fail_intervals = config.get('outbound.temp_fail_intervals');
+        cfg.temp_fail_intervals = config.get('outbound.temp_fail_intervals')
     }
     if (!cfg.maxTempFailures) {
-        cfg.maxTempFailures = config.get('outbound.maxTempFailures') || 13;
+        cfg.maxTempFailures = config.get('outbound.maxTempFailures') || 13
     }
     if (!cfg.concurrency_max) {
-        cfg.concurrency_max = config.get('outbound.concurrency_max') || 10000;
+        cfg.concurrency_max = config.get('outbound.concurrency_max') || 10000
     }
     if (!cfg.connect_timeout) {
-        cfg.connect_timeout = 30;
+        cfg.connect_timeout = 30
     }
     if (!cfg.received_header) {
-        cfg.received_header = config.get('outbound.received_header') || 'Haraka outbound';
+        cfg.received_header = config.get('outbound.received_header') || 'Haraka outbound'
     }
 
-    exports.set_temp_fail_intervals();
+    exports.set_temp_fail_intervals()
 }
 
 exports.set_temp_fail_intervals = function () {
@@ -50,80 +55,80 @@ exports.set_temp_fail_intervals = function () {
     //      it with the equivalent times of maxTempFailures using the original 2^N formula
     //   3) the word "none" can be specified if you do not want to retry a temp failure,
     //      equivalent behavior of specifying maxTempFailures=1
-    const { cfg } = this;
+    const { cfg } = this
 
     // Fallback function to create an array of the original retry times
-    function set_old_defaults () {
-        cfg.temp_fail_intervals = [];
-        for (let i=1; i<cfg.maxTempFailures; i++) {
-            cfg.temp_fail_intervals.push(2 ** (i + 5));
+    function set_old_defaults() {
+        cfg.temp_fail_intervals = []
+        for (let i = 1; i < cfg.maxTempFailures; i++) {
+            cfg.temp_fail_intervals.push(2 ** (i + 5))
         }
     }
 
     // Helpful error function in case of parsing failure
-    function error (i, msg) {
-        logger.error(exports, `temp_fail_intervals syntax error parsing element ${i}: ${msg}`);
-        logger.warn(exports, 'Setting outbound temp_fail_intervals to old defaults');
-        set_old_defaults();
+    function error(i, msg) {
+        logger.error(exports, `temp_fail_intervals syntax error parsing element ${i}: ${msg}`)
+        logger.warn(exports, 'Setting outbound temp_fail_intervals to old defaults')
+        set_old_defaults()
     }
 
     // If the new value isn't specified, then create the old defaults
     if (!cfg.temp_fail_intervals) {
-        return set_old_defaults();
+        return set_old_defaults()
     }
 
     // If here then turn the text input into an expanded array of intervals (in seconds)
     // i.e, turn "1m,5m*2,1h*3" into [60,300,300,3600,3600,3600]
     // Parse manually to do better syntax checking and provide better failure messages
-    const times = [];
-    let input = cfg.temp_fail_intervals.replace(/\s+/g, '').toLowerCase();
-    if (input.length === 0) return error(0, 'nothing specified');
+    const times = []
+    let input = cfg.temp_fail_intervals.replace(/\s+/g, '').toLowerCase()
+    if (input.length === 0) return error(0, 'nothing specified')
     if (input === 'none') {
-        cfg.temp_fail_intervals = [];
-        return;
+        cfg.temp_fail_intervals = []
+        return
     }
     input = input.split(',')
 
-    for (let i=0; i<input.length; i++) {
-        const delay = input[i].split('*');
-        if (delay.length === 1) delay.push(1);
-        else if (delay.length === 2) delay[1] = Number(delay[1]);
-        else return error(i, 'too many *');
-        if (!Number.isInteger(delay[1])) return error(i, 'multiplier is not an integer');
+    for (let i = 0; i < input.length; i++) {
+        const delay = input[i].split('*')
+        if (delay.length === 1) delay.push(1)
+        else if (delay.length === 2) delay[1] = Number(delay[1])
+        else return error(i, 'too many *')
+        if (!Number.isInteger(delay[1])) return error(i, 'multiplier is not an integer')
 
-        if (delay[0].length < 2) error(i, 'invalid time span');
-        const symbol = delay[0].charAt(delay[0].length - 1);
-        let num = Number(delay[0].slice(0, -1));
-        if (isNaN(num)) return error(i, 'invalid number or symbol');
+        if (delay[0].length < 2) error(i, 'invalid time span')
+        const symbol = delay[0].charAt(delay[0].length - 1)
+        let num = Number(delay[0].slice(0, -1))
+        if (isNaN(num)) return error(i, 'invalid number or symbol')
 
         switch (symbol) {
             case 's':
                 // do nothing, this is the base unit
-                break;
+                break
             case 'm':
-                num *= 60;
-                break;
+                num *= 60
+                break
             case 'h':
-                num *= 3600;
-                break;
+                num *= 3600
+                break
             case 'd':
-                num *= 86400;
-                break;
+                num *= 86400
+                break
             default:
-                return error(i, 'invalid time span symbol');
+                return error(i, 'invalid time span symbol')
         }
         // Sanity check (what should this number be?)
         if (num < 5) return error(i, 'delay time too small, should be >=5 seconds')
         for (let j = 0; j < delay[1]; j++) {
-            times.push(num);
+            times.push(num)
         }
     }
 
     // One last check, just in case...should never be true
-    if (times.length === 0) return error(0, 'unexpected parsing result');
+    if (times.length === 0) return error(0, 'unexpected parsing result')
 
     // If here, success, so actually store the calculated array in the config
-    cfg.temp_fail_intervals = times;
+    cfg.temp_fail_intervals = times
 }
 
-load_config();
+load_config()

package/outbound/fsync_writestream.js

@@ -1,45 +1,44 @@
-'use strict';
+'use strict'
 
-const fs = require('node:fs');
+const fs = require('node:fs')
 
 class FsyncWriteStream extends fs.WriteStream {
-    constructor (path, options) {
-        super(path, options);
+    constructor(path, options) {
+        super(path, options)
     }
 
-    close (cb) {
-        const self = this;
-        if (cb) this.once('close', cb);
+    close(cb) {
+        const self = this
+        if (cb) this.once('close', cb)
 
         if (this.closed || 'number' !== typeof this.fd) {
             if ('number' !== typeof this.fd) {
-                this.once('open', close);
-                return;
+                this.once('open', close)
+                return
             }
-            return setImmediate(this.emit.bind(this, 'close'));
+            return setImmediate(this.emit.bind(this, 'close'))
         }
-        this.closed = true;
-        close();
+        this.closed = true
+        close()
 
-        function close (fd) {
-            fs.fsync(fd || self.fd, er => {
+        function close(fd) {
+            fs.fsync(fd || self.fd, (er) => {
                 if (er) {
-                    self.emit('error', er);
-                    return;
+                    self.emit('error', er)
+                    return
                 }
 
-                fs.close(fd || self.fd, err => {
+                fs.close(fd || self.fd, (err) => {
                     if (err) {
-                        self.emit('error', err);
+                        self.emit('error', err)
+                    } else {
+                        self.emit('close')
                     }
-                    else {
-                        self.emit('close');
-                    }
-                });
-                self.fd = null;
-            });
+                })
+                self.fd = null
+            })
         }
     }
 }
 
-module.exports = FsyncWriteStream;
+module.exports = FsyncWriteStream