Haraka 3.2.1 → 3.3.1

package/address.js

@@ -1,53 +0,0 @@
-'use strict'
-
-// SUNSET 2027: Haraka core constructs envelope addresses with
-// @haraka/email-address, whose `.address` / `.host` are string
-// properties. Core itself — and a large body of bundled and
-// third-party plugins — still use the historical address-rfc2821 /
-// address-rfc2822 *method* contract (`addr.address()`, `addr.host()`).
-//
-// `asLegacy()` wraps each instance so both the new string-property API
-// and the legacy callable form work during the transition. The wrap is
-// idempotent, and `unwrapLegacy()` recovers the raw instance so the
-// outbound queue's JSON re-hydration copies primitive string fields
-// rather than the callable accessors.
-//
-// Once the ecosystem has migrated, delete this module, require
-// `Address` straight from '@haraka/email-address', and drop the wrapper
-// (see @haraka/email-address lib/legacy.js).
-
-const { Address: BaseAddress, asLegacy, unwrapLegacy } = require('@haraka/email-address')
-
-class Address extends BaseAddress {
-    constructor(...args) {
-        // never re-hydrate from a wrapped instance — copy raw strings
-        if (args.length) args[0] = unwrapLegacy(args[0])
-        // `new Address(user, host)` where `host` is another wrapped
-        // address's `.host` — the SUNSET-2027 callable accessor is
-        // `typeof 'function'`, which BaseAddress would mistake for an
-        // options object. Coerce it back to the primitive string.
-        if (args.length >= 2 && typeof args[1] === 'function') {
-            args[1] = String(args[1])
-        }
-        super(...args)
-        return asLegacy(this)
-    }
-
-    // Preserve the address-rfc2821 wire shape so existing on-disk queue
-    // files stay byte-compatible across the upgrade and re-hydrate
-    // unchanged. @haraka/email-address additionally carries
-    // phrase/comment/group/opts, which are irrelevant to envelope
-    // addresses and must not leak into the persisted todo. SUNSET 2027.
-    toJSON() {
-        const out = {
-            original: this.original,
-            original_host: this.original_host,
-            host: this.host,
-            user: this.user,
-        }
-        if (this.is_utf8) out.is_utf8 = true
-        return out
-    }
-}
-
-module.exports = { Address }

package/endpoint.js

@@ -1,96 +0,0 @@
-'use strict'
-// Socket address parser/formatter and server binding helper
-
-const fs = require('node:fs/promises')
-const net = require('node:net')
-
-function parseSockaddr(addr, defaultPort = 0) {
-    let match
-    if (/^[0-9]+$/.test(addr)) return { host: '::', port: parseInt(addr, 10) }
-
-    const lastColon = addr.lastIndexOf(':')
-    if (lastColon !== -1) {
-        const host = addr.slice(0, lastColon)
-        const port = addr.slice(lastColon + 1)
-
-        if (host.includes(':') && /^\d+$/.test(port) && net.isIP(host) === 6) {
-            return { host: host.toLowerCase(), port: parseInt(port, 10) }
-        }
-    }
-    if (net.isIP(addr) === 6) return { host: addr.toLowerCase(), port: defaultPort }
-
-    if ((match = /^(\d{1,3}(?:\.\d{1,3}){3})(?::(\d+))?$/.exec(addr)))
-        return { host: match[1], port: match[2] !== undefined ? parseInt(match[2], 10) : defaultPort }
-    if ((match = /^\[([0-9a-fA-F:]+)\](?::(\d+))?$/.exec(addr)))
-        return { host: match[1].toLowerCase(), port: match[2] !== undefined ? parseInt(match[2], 10) : defaultPort }
-    if (
-        (match =
-            /^([a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?)*)(?::(\d+))?$/.exec(
-                addr,
-            ))
-    )
-        return { host: match[1].toLowerCase(), port: match[2] !== undefined ? parseInt(match[2], 10) : defaultPort }
-    if (addr.includes('/')) return { path: addr }
-    throw new Error(`Invalid socket address ${addr}`)
-}
-
-module.exports = function endpoint(addr, defaultPort) {
-    try {
-        if ('string' === typeof addr || 'number' === typeof addr) {
-            addr = parseSockaddr(addr, defaultPort)
-            const match = /^(.*):([0-7]{3})$/.exec(addr.path || '')
-            if (match) {
-                addr.path = match[1]
-                addr.mode = match[2]
-            }
-        }
-    } catch (err) {
-        // Return the parse exception instead of throwing it
-        return err
-    }
-    return new Endpoint(addr)
-}
-
-class Endpoint {
-    constructor(addr) {
-        if (addr.path) {
-            this.path = addr.path
-            if (addr.mode) this.mode = addr.mode
-        } else {
-            // Handle server.address() return as well as parsed host/port
-            const host = addr.address || addr.host || '::0'
-            // Normalize '::' to '::0'
-            this.host = '::' === host ? '::0' : host
-            this.port = parseInt(addr.port, 10)
-        }
-    }
-
-    toString() {
-        if (this.mode) return `${this.path}:${this.mode}`
-        if (this.path) return this.path
-        if (this.host.includes(':')) return `[${this.host}]:${this.port}`
-        return `${this.host}:${this.port}`
-    }
-
-    // Make server listen on this endpoint, w/optional options
-    async bind(server, opts) {
-        opts = { ...opts }
-
-        const mode = this.mode ? parseInt(this.mode, 8) : false
-        if (this.path) {
-            opts.path = this.path
-            await fs.rm(this.path, { force: true }) // errors are ignored when force is true
-        } else {
-            opts.host = this.host
-            opts.port = this.port
-        }
-
-        return new Promise((resolve, reject) => {
-            server.listen(opts, async (err) => {
-                if (err) return reject(err)
-                if (mode) await fs.chmod(opts.path, mode)
-                resolve()
-            })
-        })
-    }
-}

package/host_pool.js

@@ -1,169 +0,0 @@
-'use strict'
-
-const net = require('node:net')
-const utils = require('haraka-utils')
-
-/* HostPool:
- *
- * Starts with a pool of backend hosts from a "forwarding_host_pool"
- * configuration that looks like this (port defaults to 25 if not set):
- *
- *      1.1.1.1:11, 2.2.2.2:22, 3.3.3.3:33
- *
- * It randomizes the list and then gives then out sequentially (for
- * predictability).
- *
- * If failed() is called with one of the hosts, we mark it down for retry_secs
- * and don't give it out again until that period has passed.
- *
- * If *all* the hosts have been marked down, ignore the marks and give
- * out the next host. That's to keep a random short-lived but widespread
- * network failure from taking the whole system down.
- */
-
-const logger = require('./logger')
-
-class HostPool {
-    // takes a comma/space-separated list of ip:ports
-    //  1.1.1.1:22,  3.3.3.3:44
-    constructor(hostports_str, retry_secs) {
-        const hosts = (hostports_str || '')
-            .trim()
-            .split(/[\s,]+/)
-            .map((hostport) => {
-                const splithost = hostport.split(/:/)
-                if (!splithost[1]) {
-                    splithost[1] = 25
-                }
-                return {
-                    host: splithost[0],
-                    port: splithost[1],
-                }
-            })
-        this.hostports_str = hostports_str
-        this.hosts = utils.shuffle(hosts)
-        this.dead_hosts = {} // hostport => true/false
-        this.last_i = 0 // the last one we checked
-        this.retry_secs = retry_secs || 10
-    }
-
-    /* failed
-     *
-     * Part of the external API for this module. Call it when you see a failure to
-     * this backend host and it'll come out of the pool and put into the recheck
-     * timer.
-     */
-    failed(host, port) {
-        const self = this
-        const key = `${host}:${port}`
-        const retry_msecs = self.retry_secs * 1000
-        self.dead_hosts[key] = true
-
-        function cb_if_still_dead() {
-            logger.warn(`${host} ${key} is still dead, will retry in ${self.retry_secs} secs`)
-            self.dead_hosts[key] = true
-            // console.log(1);
-            setTimeout(() => {
-                self.probe_dead_host(host, port, cb_if_still_dead, cb_if_alive)
-            }, retry_msecs)
-        }
-
-        function cb_if_alive() {
-            // console.log(2);
-            logger.info(`${host} ${key} is back! adding back into pool`)
-            delete self.dead_hosts[key]
-        }
-
-        setTimeout(() => {
-            self.probe_dead_host(host, port, cb_if_still_dead, cb_if_alive)
-        }, retry_msecs)
-    }
-
-    /* probe_dead_host
-     *
-     * When the timer fires, we'll ping the host, and if it's still dead we'll
-     * update the dead_hosts list.  If it's back online, we just don't touch the
-     * dead_hosts lists, and the next time get_host() is called, it'll be in the
-     * mix.
-     */
-    probe_dead_host(host, port, cb_if_still_dead, cb_if_alive) {
-        logger.info(`probing dead host ${host}:${port}`)
-
-        const connect_timeout_ms = 200 // keep it snappy
-        let s
-        try {
-            s = this.get_socket()
-            s.setTimeout(connect_timeout_ms, () => {
-                // nobody home, it's still dead
-                s.destroy()
-                cb_if_still_dead()
-            })
-            s.on('error', (e) => {
-                // silently catch all errors - assume the port is closed
-                s.destroy()
-                cb_if_still_dead()
-            })
-
-            s.connect(port, host, () => {
-                cb_if_alive()
-                s.destroy() // will this conflict with setTimeout's s.destroy?
-            })
-        } catch (e) {
-            // only way to catch run-time javascript errors in here;
-            console.log(`ERROR in probe_dead_host, got error ${e}`)
-            throw e
-        }
-    }
-
-    /* get_socket
-     *
-     * so we can override in unit test
-     */
-    get_socket() {
-        return new net.Socket()
-    }
-
-    /* get_host
-     *
-     * This approach borrowed from the danga mogilefs client code
-     *
-     * If all the hosts look dead, it returns the next one it would have tried
-     * anyway. That should make it more forgiving about transient but widespread
-     * network problems that make all the hosts look dead.
-     */
-    get_host() {
-        let host
-        let found
-
-        let first_i = this.last_i + 1
-        if (first_i >= this.hosts.length) {
-            first_i = 0
-        }
-
-        for (let i = 0; i < this.hosts.length; ++i) {
-            let j = i + first_i
-            if (j >= this.hosts.length) {
-                j -= this.hosts.length
-            }
-            host = this.hosts[j]
-            const key = `${host.host}:${host.port}`
-            if (this.dead_hosts[key]) {
-                continue
-            }
-            this.last_i = j
-            found = true
-            break
-        }
-        if (found) {
-            return host
-        } else {
-            logger.warn(
-                `no working hosts found, retrying a dead one, config (probably from smtp_forward.forwarding_host_pool) is '${this.hostports_str}'`,
-            )
-            this.last_i = first_i
-            return this.hosts[first_i]
-        }
-    }
-}
-
-module.exports = HostPool

package/outbound/fsync_writestream.js

@@ -1,44 +0,0 @@
-'use strict'
-
-const fs = require('node:fs')
-
-class FsyncWriteStream extends fs.WriteStream {
-    constructor(path, options) {
-        super(path, options)
-    }
-
-    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
-            }
-            return setImmediate(this.emit.bind(this, 'close'))
-        }
-        this.closed = true
-        close()
-
-        function close(fd) {
-            fs.fsync(fd || self.fd, (er) => {
-                if (er) {
-                    self.emit('error', er)
-                    return
-                }
-
-                fs.close(fd || self.fd, (err) => {
-                    if (err) {
-                        self.emit('error', err)
-                    } else {
-                        self.emit('close')
-                    }
-                })
-                self.fd = null
-            })
-        }
-    }
-}
-
-module.exports = FsyncWriteStream

package/outbound/timer_queue.js

@@ -1,86 +0,0 @@
-'use strict'
-
-const logger = require('../logger')
-
-class TQTimer {
-    constructor(id, fire_time, cb) {
-        this.id = id
-        this.fire_time = fire_time
-        this.cb = cb
-    }
-
-    cancel() {
-        this.cb = null
-    }
-}
-
-class TimerQueue {
-    constructor(interval = 1000) {
-        this.name = 'outbound/timer_queue'
-        this.queue = []
-        this.interval_timer = setInterval(() => {
-            this.fire()
-        }, interval)
-        this.interval_timer.unref() // allow server to exit
-    }
-
-    add(id, ms, cb) {
-        const fire_time = Date.now() + ms
-
-        const timer = new TQTimer(id, fire_time, cb)
-
-        if (this.queue.length === 0 || fire_time >= this.queue[this.queue.length - 1].fire_time) {
-            this.queue.push(timer)
-            return timer
-        }
-
-        for (let i = 0; i < this.queue.length; i++) {
-            if (this.queue[i].fire_time > fire_time) {
-                this.queue.splice(i, 0, timer)
-                return timer
-            }
-        }
-
-        throw 'Should never get here'
-    }
-
-    discard(id) {
-        for (let i = 0; i < this.queue.length; i++) {
-            if (this.queue[i].id === id) {
-                this.queue[i].cancel()
-                return this.queue.splice(i, 1)
-            }
-        }
-
-        throw `${id} not found`
-    }
-
-    fire() {
-        if (this.queue.length === 0) return
-
-        const now = Date.now()
-
-        while (this.queue.length && this.queue[0].fire_time <= now) {
-            const to_run = this.queue.shift()
-            if (to_run.cb) to_run.cb()
-        }
-    }
-
-    length() {
-        return this.queue.length
-    }
-
-    drain() {
-        logger.debug(this, `Draining ${this.queue.length} items from the queue`)
-        while (this.queue.length) {
-            const to_run = this.queue.shift()
-            if (to_run.cb) to_run.cb()
-        }
-    }
-
-    shutdown() {
-        clearInterval(this.interval_timer)
-    }
-}
-
-module.exports = TimerQueue

package/rfc1869.js

@@ -1,93 +0,0 @@
-'use strict'
-// RFC 1869 command parser
-
-// 6.  MAIL FROM and RCPT TO Parameters
-// [...]
-//
-//   esmtp-cmd        ::= inner-esmtp-cmd [SP esmtp-parameters] CR LF
-//   esmtp-parameters ::= esmtp-parameter *(SP esmtp-parameter)
-//   esmtp-parameter  ::= esmtp-keyword ["=" esmtp-value]
-//   esmtp-keyword    ::= (ALPHA / DIGIT) *(ALPHA / DIGIT / "-")
-//
-//                        ; syntax and values depend on esmtp-keyword
-//   esmtp-value      ::= 1*<any CHAR excluding "=", SP, and all
-//                           control characters (US ASCII 0-31
-//                           inclusive)>
-//
-//                        ; The following commands are extended to
-//                        ; accept extended parameters.
-//   inner-esmtp-cmd  ::= ("MAIL FROM:" reverse-path)   /
-//                        ("RCPT TO:" forward-path)
-
-/* eslint no-control-regex: 0 */
-const chew_regexp = /\s+([A-Za-z0-9][A-Za-z0-9-]*(?:=[^= \x00-\x1f]+)?)$/
-
-exports.parse = (type, line, strict) => {
-    let params = []
-    line = new String(line).replace(/\s*$/, '')
-    if (type === 'mail') {
-        line = line.replace(strict ? /from:/i : /from:\s*/i, '')
-    } else {
-        line = line.replace(strict ? /to:/i : /to:\s*/i, '')
-    }
-
-    while (1) {
-        const old_length = line.length
-        line = line.replace(chew_regexp, (str, p1) => {
-            params.push(p1)
-            return ''
-        })
-        if (old_length === line.length) break
-    }
-
-    params = params.reverse()
-
-    // the above will "fail" (i.e. all of the line in params) on
-    // some addresses without <> like
-    //    MAIL FROM: user=name@example.net
-    // or RCPT TO: postmaster
-
-    // let's see if $line contains nothing and use the first value as address:
-    if (line.length) {
-        // parameter syntax error, i.e. not all of the arguments were
-        // stripped by the while() loop:
-        if (line.match(/@.*\s/)) {
-            throw new Error(`Syntax error in parameters ("${line}")`)
-        }
-
-        params.unshift(line)
-    }
-
-    line = params.shift() || ''
-    if (strict) {
-        if (!line.match(/^<.*>$/)) {
-            throw new Error(`Invalid format of ${type} command: ${line}`)
-        }
-    }
-
-    if (type === 'mail') {
-        if (!line.length) {
-            return ['<>'] // 'MAIL FROM:' --> 'MAIL FROM:<>'
-        }
-        if (line.match(/@.*\s/)) {
-            throw new Error('Syntax error in parameters')
-        }
-    } else {
-        // console.log(`Looking at ${line}`);
-        if (line.match(/@.*\s/)) {
-            throw new Error('Syntax error in parameters')
-        }
-        if (line.match(/\s/)) {
-            throw new Error('Syntax error in parameters')
-        }
-        if (line.match(/@/)) {
-            if (!line.match(/^<.*>$/)) line = `<${line}>`
-        } else if (!line.match(/^<(postmaster|abuse)>$/i)) {
-            throw new Error(`Syntax error in address: ${line}`)
-        }
-    }
-
-    params.unshift(line)
-
-    return params
-}

package/test/endpoint.js

@@ -1,128 +0,0 @@
-'use strict'
-
-const { describe, it, beforeEach, afterEach } = require('node:test')
-const assert = require('node:assert')
-
-const mock = require('mock-require')
-const endpoint = require('../endpoint')
-
-describe('endpoint', () => {
-    it('toString()', () => {
-        assert.equal(endpoint(25), '[::0]:25')
-        assert.equal(endpoint('10.0.0.3', 42), '10.0.0.3:42')
-        assert.equal(endpoint('/foo/bar.sock'), '/foo/bar.sock')
-        assert.equal(endpoint('/foo/bar.sock:770'), '/foo/bar.sock:770')
-        assert.equal(endpoint({ address: '::0', port: 80 }), '[::0]:80')
-    })
-
-    describe('parse', () => {
-        it('Number as port', () => {
-            assert.deepEqual(endpoint(25), { host: '::0', port: 25 })
-        })
-
-        it('Unbracketed IPv6 host uses default port', () => {
-            assert.deepEqual(endpoint('::0', 25), {
-                host: '::0',
-                port: 25,
-            })
-        })
-
-        it('Unbracketed IPv6 host:port parses correctly (PR #3552 compatibility)', () => {
-            assert.deepEqual(endpoint('::0:25'), {
-                host: '::0',
-                port: 25,
-            })
-        })
-
-        it('Default port if only host', () => {
-            assert.deepEqual(endpoint('10.0.0.3', 42), {
-                host: '10.0.0.3',
-                port: 42,
-            })
-        })
-
-        it('Bracketed IPv6 host is normalized to lowercase', () => {
-            assert.deepEqual(endpoint('[ABCD::EF01]:2525'), {
-                host: 'abcd::ef01',
-                port: 2525,
-            })
-        })
-
-        it('Unix socket', () => {
-            assert.deepEqual(endpoint('/foo/bar.sock'), {
-                path: '/foo/bar.sock',
-            })
-        })
-
-        it('Unix socket w/mode', () => {
-            assert.deepEqual(endpoint('/foo/bar.sock:770'), {
-                path: '/foo/bar.sock',
-                mode: '770',
-            })
-        })
-
-        it('Invalid unbracketed IPv6 host with non-numeric tail returns Error', () => {
-            const ep = endpoint('::0:port')
-            assert.equal(ep instanceof Error, true)
-            assert.match(ep.message, /Invalid socket address/)
-        })
-    })
-
-    describe('bind()', () => {
-        beforeEach(() => {
-            // Mock filesystem and log server + fs method calls
-            const modes = (this.modes = {})
-            const log = (this.log = [])
-
-            this.server = {
-                listen(opts, cb) {
-                    log.push(['listen', opts])
-                    if (cb) cb()
-                },
-            }
-
-            this.mockfs = {
-                chmod(path, mode, ...args) {
-                    log.push(['chmod', path, mode, ...args])
-                    modes[path] = mode
-                },
-                rm(path, ...args) {
-                    log.push(['rm', path, ...args])
-                },
-            }
-
-            mock('node:fs/promises', this.mockfs)
-            this.endpoint = mock.reRequire('../endpoint')
-        })
-
-        afterEach(() => {
-            mock.stop('node:fs/promises')
-        })
-
-        it('IP socket', async () => {
-            await this.endpoint('10.0.0.3:42').bind(this.server, {
-                backlog: 19,
-            })
-            assert.deepEqual(this.log, [['listen', { host: '10.0.0.3', port: 42, backlog: 19 }]])
-        })
-
-        it('Unix socket', async () => {
-            await this.endpoint('/foo/bar.sock').bind(this.server, {
-                readableAll: true,
-            })
-            assert.deepEqual(this.log, [
-                ['rm', '/foo/bar.sock', { force: true }],
-                ['listen', { path: '/foo/bar.sock', readableAll: true }],
-            ])
-        })
-
-        it('Unix socket w/mode', async () => {
-            await this.endpoint('/foo/bar.sock:764').bind(this.server)
-            assert.deepEqual(this.log, [
-                ['rm', '/foo/bar.sock', { force: true }],
-                ['listen', { path: '/foo/bar.sock' }],
-                ['chmod', '/foo/bar.sock', 0o764],
-            ])
-        })
-    })
-})