haraka 0.0.33 → 3.3.0

package/logger.js

@@ -0,0 +1,322 @@
+'use strict'
+// Log class
+
+const util = require('node:util')
+const tty = require('node:tty')
+
+const config = require('haraka-config')
+const constants = require('haraka-constants')
+
+let plugins
+
+const regex = /(^$|[ ="\\])/
+const escape_replace_regex = /["\\]/g
+
+function stringify(obj) {
+    let str = ''
+    let key
+    for (key in obj) {
+        let v = obj[key]
+        if (v == null) {
+            str += `${key}="" `
+            continue
+        }
+        v = v.toString()
+        if (regex.test(v)) {
+            str += `${key}="${v.replace(escape_replace_regex, '\\$&')}" `
+        } else {
+            str += `${key}=${v} `
+        }
+    }
+    return str.trim()
+}
+
+const logger = exports
+
+logger.levels = {
+    DATA: 9,
+    PROTOCOL: 8,
+    DEBUG: 7,
+    INFO: 6,
+    NOTICE: 5,
+    WARN: 4,
+    ERROR: 3,
+    CRIT: 2,
+    ALERT: 1,
+    EMERG: 0,
+}
+const level_names = Object.keys(logger.levels)
+
+for (const le in logger.levels) {
+    logger.levels[`LOG${le}`] = logger.levels[le]
+    logger[`LOG${le}`] = logger.levels[le]
+}
+
+logger.formats = {
+    DEFAULT: 'DEFAULT',
+    LOGFMT: 'LOGFMT',
+    JSON: 'JSON',
+}
+
+logger.loglevel = logger.levels.WARN
+logger.format = logger.formats.DEFAULT
+logger.timestamps = false
+logger.deferred_logs = []
+logger.name = 'logger'
+
+logger.colors = {
+    DATA: 'green',
+    PROTOCOL: 'green',
+    DEBUG: 'grey',
+    INFO: 'cyan',
+    NOTICE: 'blue',
+    WARN: 'red',
+    ERROR: 'red',
+    CRIT: 'red',
+    ALERT: 'red',
+    EMERG: 'red',
+}
+
+const stdout_is_tty = tty.isatty(process.stdout.fd)
+
+logger._init = function () {
+    this.load_log_ini()
+    this._init_loglevel()
+    this._init_timestamps()
+}
+
+logger.load_log_ini = function () {
+    this.cfg = config.get(
+        'log.ini',
+        {
+            booleans: ['+main.timestamps'],
+        },
+        () => {
+            this.load_log_ini()
+        },
+    )
+
+    this.set_loglevel(this.cfg.main.level)
+    this.set_timestamps(this.cfg.main.timestamps)
+    this.set_format(this.cfg.main.format)
+}
+
+logger.colorize = (color, str) => {
+    if (!util.inspect.colors[color]) {
+        return str
+    } // unknown color
+    return `\u001b[${util.inspect.colors[color][0]}m${str}\u001b[${util.inspect.colors[color][1]}m`
+}
+
+logger.dump_logs = (cb) => {
+    while (logger.deferred_logs.length > 0) {
+        const log_item = logger.deferred_logs.shift()
+        plugins.run_hooks('log', logger, log_item)
+    }
+    // Run callback after flush
+    if (cb) process.stdout.write('', cb)
+    return true
+}
+
+logger.dump_and_exit = function (code) {
+    this.dump_logs(() => {
+        if (typeof code === 'function') return code()
+        process.exit(code)
+    })
+}
+
+logger.log = (level, data, logobj) => {
+    if (level === 'PROTOCOL') {
+        data = data.replace(/\n/g, '\\n')
+    }
+    data = data.replace(/\r/g, '\\r').replace(/\n$/, '')
+
+    const item = { level, data, obj: logobj }
+
+    // buffer until plugins are loaded
+    const emptyPluginList = !plugins || (Array.isArray(plugins.plugin_list) && !plugins.plugin_list.length)
+    if (emptyPluginList) {
+        logger.deferred_logs.push(item)
+        return true
+    }
+
+    // process buffered logs
+    while (logger.deferred_logs.length > 0) {
+        const log_item = logger.deferred_logs.shift()
+        plugins.run_hooks('log', logger, log_item)
+    }
+
+    plugins.run_hooks('log', logger, item)
+    return true
+}
+
+logger.log_respond = (retval, msg, data) => {
+    // any other return code is irrelevant
+    if (retval !== constants.cont) return false
+
+    let timestamp_string = ''
+    if (logger.timestamps) timestamp_string = `${new Date().toISOString()} `
+
+    const color = logger.colors[data.level]
+    if (color && stdout_is_tty) {
+        process.stdout.write(`${timestamp_string}${logger.colorize(color, data.data)}\n`)
+    } else {
+        process.stdout.write(`${timestamp_string}${data.data}\n`)
+    }
+
+    return true
+}
+
+logger.set_loglevel = function (level) {
+    if (level === undefined || level === null) return
+
+    const loglevel_num = parseInt(level)
+    if (typeof level === 'string') {
+        this.log('INFO', `loglevel: ${level.toUpperCase()}`)
+        logger.loglevel = logger.levels[level.toUpperCase()]
+    } else {
+        logger.loglevel = loglevel_num
+    }
+
+    if (!Number.isInteger(logger.loglevel)) {
+        this.log('WARN', `invalid loglevel: ${level} defaulting to LOGWARN`)
+        logger.loglevel = logger.levels.WARN
+    }
+}
+
+logger.set_format = function (format) {
+    if (format) {
+        logger.format = logger.formats[format.toUpperCase()]
+        this.log('INFO', `log format: ${format.toUpperCase()}`)
+    } else {
+        logger.format = null
+    }
+    if (!logger.format) {
+        this.log('WARN', `invalid log format: ${format} defaulting to DEFAULT`)
+        logger.format = logger.formats.DEFAULT
+    }
+}
+
+logger._init_loglevel = function () {
+    const _loglevel = config.get('loglevel', 'value', () => {
+        this._init_loglevel()
+    })
+
+    this.set_loglevel(_loglevel)
+}
+
+logger.would_log = (level) => {
+    if (logger.loglevel < level) return false
+    return true
+}
+
+logger.set_timestamps = (value) => {
+    logger.timestamps = !!value
+}
+
+logger._init_timestamps = function () {
+    const _timestamps = config.get('log_timestamps', 'value', () => {
+        this._init_timestamps()
+    })
+
+    // If we've already been toggled to true by the cfg, we should respect this.
+    this.set_timestamps(logger.timestamps || _timestamps)
+}
+
+logger._init()
+
+logger.log_if_level = (level, key, origin) =>
+    function () {
+        if (logger.loglevel < logger[key]) return
+
+        let logobj = {
+            level,
+            uuid: '-',
+            origin: origin || 'core',
+            message: '',
+        }
+
+        for (const data of arguments) {
+            if (typeof data !== 'object') {
+                logobj.message += data
+                continue
+            }
+            if (!data) continue
+
+            // if the object is a connection, add the connection id
+            if (data.constructor?.name === 'Connection') {
+                logobj.uuid = data.uuid
+                if (data.tran_count > 0) logobj.uuid += `.${data.tran_count}`
+            } else if (data instanceof plugins.Plugin) {
+                logobj.origin = data.name
+            } else if (Object.hasOwn(data, 'name')) {
+                // outbound
+                logobj.origin = data.name
+                if (Object.hasOwn(data, 'uuid')) logobj.uuid = data.uuid
+                if (data.todo?.uuid) logobj.uuid = data.todo.uuid // outbound/hmail
+            } else if (logger.format === logger.formats.LOGFMT && data.constructor === Object) {
+                logobj = { ...logobj, ...data }
+            } else if (logger.format === logger.formats.JSON && data.constructor === Object) {
+                logobj = { ...logobj, ...data }
+            } else if (Object.hasOwn(data, 'uuid')) {
+                // outbound/client_pool
+                logobj.uuid = data.uuid
+            } else if (data.constructor === Object) {
+                if (!logobj.message.endsWith(' ')) logobj.message += ' '
+                logobj.message += stringify(data)
+            } else {
+                logobj.message += util.inspect(data)
+            }
+        }
+
+        switch (logger.format) {
+            case logger.formats.LOGFMT:
+                logger.log(level, stringify(logobj))
+                break
+            case logger.formats.JSON:
+                logger.log(level, JSON.stringify(logobj))
+                break
+            case logger.formats.DEFAULT:
+            default:
+                logger.log(level, `[${logobj.level}] [${logobj.uuid}] [${logobj.origin}] ${logobj.message}`)
+        }
+        return true
+    }
+
+logger.add_log_methods = (object, logName) => {
+    if (!object) return
+
+    if (typeof object === 'function') {
+        // add logging methods to class prototypes (Connection, Plugin, etc.)
+
+        for (const level of level_names.map((l) => l.toLowerCase())) {
+            object.prototype[`log${level}`] = (function (level) {
+                return function () {
+                    logger[level].apply(logger, [this, ...arguments])
+                }
+            })(`log${level}`)
+        }
+    } else if (typeof object === 'object') {
+        // add logging methods to objects
+
+        for (const level of level_names) {
+            // objects gets log function names: loginfo, logwarn, logdebug, ...
+            const fnNames = [`log${level.toLowerCase()}`]
+
+            // logger also gets short names
+            if (Object.hasOwn(object, 'name') && object.name === 'logger') {
+                fnNames.push(level.toLowerCase())
+            }
+
+            for (const fnName of fnNames) {
+                if (Object.hasOwn(object, fnName)) continue // already added
+                object[fnName] = logger.log_if_level(level, `LOG${level}`, logName)
+            }
+        }
+    }
+}
+
+logger.add_log_methods(logger)
+
+// load these down here so it sees all the logger methods compiled above
+plugins = require('./plugins')

package/outbound/client_pool.js

@@ -0,0 +1,59 @@
+'use strict'
+
+const util = require('node:util')
+
+const utils = require('haraka-utils')
+const net_utils = require('haraka-net-utils')
+
+const tls_socket = require('../tls_socket')
+const logger = require('../logger')
+const obc = require('./config')
+
+exports.name = 'outbound'
+
+// Get a socket for the given attributes.
+exports.get_client = function (mx, callback) {
+    const socketArgs = mx.path ? { path: mx.path } : { port: mx.port, host: mx.exchange, localAddress: mx.bind }
+
+    const socket = tls_socket.connect(socketArgs)
+    net_utils.add_line_processor(socket)
+
+    socket.name = `outbound::${JSON.stringify(socketArgs)}`
+    socket.__uuid = utils.uuid()
+    socket.setTimeout(obc.cfg.connect_timeout * 1000)
+
+    logger.debug(exports, `created ${socket.name}`, { uuid: socket.__uuid })
+
+    socket.once('connect', () => {
+        socket.removeAllListeners('error') // these get added after callback
+        socket.removeAllListeners('timeout')
+        callback(null, socket)
+    })
+
+    socket.once('error', (err) => {
+        socket.end()
+        socket.removeAllListeners()
+        socket.destroy()
+        const errMsg = err.message
+            ? err.message
+            : err instanceof AggregateError
+              ? err.errors.map((e) => e.message).join(', ')
+              : util.inspect(err, { depth: 3 })
+        callback(errMsg, null)
+    })
+
+    socket.once('timeout', () => {
+        socket.end()
+        socket.removeAllListeners()
+        socket.destroy()
+        callback(`connection timed out to ${socket.name}`, null)
+    })
+}
+
+exports.release_client = (socket, mx) => {
+    let logMsg = `release_client: ${socket.name}`
+    if (mx.bind) logMsg += ` from ${mx.bind}`
+    logger.debug(exports, logMsg)
+    socket.removeAllListeners()
+    socket.destroy()
+}

package/outbound/config.js

@@ -0,0 +1,134 @@
+'use strict'
+
+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)
+
+    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
+    }
+    if (!cfg.enable_tls && config.get('outbound.enable_tls')) {
+        cfg.enable_tls = true
+    }
+    if (!cfg.temp_fail_intervals) {
+        cfg.temp_fail_intervals = config.get('outbound.temp_fail_intervals')
+    }
+    if (!cfg.maxTempFailures) {
+        cfg.maxTempFailures = config.get('outbound.maxTempFailures') || 13
+    }
+    if (!cfg.concurrency_max) {
+        cfg.concurrency_max = config.get('outbound.concurrency_max') || 10000
+    }
+    if (!cfg.connect_timeout) {
+        cfg.connect_timeout = 30
+    }
+    if (!cfg.received_header) {
+        cfg.received_header = config.get('outbound.received_header') || 'Haraka outbound'
+    }
+
+    exports.set_temp_fail_intervals()
+}
+
+exports.set_temp_fail_intervals = function () {
+    // Set the outbound temp fail intervals (retry times) using the following rules:
+    //   1) temp_fail_intervals takes precedence over maxTempFailures if both are specified
+    //   2) if temp_fail_intervals is not specified or is illegally specified, then initialize
+    //      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
+
+    // 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))
+        }
+    }
+
+    // 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()
+    }
+
+    // If the new value isn't specified, then create the old defaults
+    if (!cfg.temp_fail_intervals) {
+        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')
+    if (input === 'none') {
+        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')
+
+        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
+            case 'm':
+                num *= 60
+                break
+            case 'h':
+                num *= 3600
+                break
+            case 'd':
+                num *= 86400
+                break
+            default:
+                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)
+        }
+    }
+
+    // One last check, just in case...should never be true
+    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
+}
+
+load_config()