Haraka 3.1.2 → 3.1.4

package/test/outbound/qfile.js

@@ -1,15 +1,15 @@
+'use strict'
+
+const { describe, it, beforeEach } = require('node:test')
 const assert = require('node:assert')
 const os = require('node:os')
 
-describe('qfile', () => {
-    describe('qfile', () => {
-        beforeEach((done) => {
-            this.qfile = require('../../outbound/qfile')
-            done()
-        })
+const qfile = require('../../outbound/qfile')
 
+describe('outbound/qfile', () => {
+    describe('name', () => {
         it('name() basic functions', () => {
-            const name = this.qfile.name()
+            const name = qfile.name()
             const split = name.split('_')
             assert.equal(split.length, 7)
             assert.equal(split[2], 0)
@@ -25,7 +25,7 @@ describe('qfile', () => {
                 uid: 'XXYYZZ',
                 host: os.hostname(),
             }
-            const name = this.qfile.name(overrides)
+            const name = qfile.name(overrides)
             const split = name.split('_')
             assert.equal(split.length, 7)
             assert.equal(split[0], overrides.arrival)
@@ -38,9 +38,9 @@ describe('qfile', () => {
 
         it('rnd_unique() is unique-ish', () => {
             const repeats = 1000
-            const u = this.qfile.rnd_unique()
+            const u = qfile.rnd_unique()
             for (let i = 0; i < repeats; i++) {
-                assert.notEqual(u, this.qfile.rnd_unique())
+                assert.notEqual(u, qfile.rnd_unique())
             }
         })
     })
@@ -49,7 +49,7 @@ describe('qfile', () => {
         it('parts() updates previous queue filenames', () => {
             // $nextattempt_$attempts_$pid_$uniq.$host
             const name = '1111_0_2222_3333.foo.example.com'
-            const parts = this.qfile.parts(name)
+            const parts = qfile.parts(name)
             assert.equal(parts.next_attempt, 1111)
             assert.equal(parts.attempts, 0)
             assert.equal(parts.pid, 2222)
@@ -65,8 +65,8 @@ describe('qfile', () => {
                 uid: 'XXYYZZ',
                 host: os.hostname(),
             }
-            const name = this.qfile.name(overrides)
-            const parts = this.qfile.parts(name)
+            const name = qfile.name(overrides)
+            const parts = qfile.parts(name)
             assert.equal(parts.arrival, overrides.arrival)
             assert.equal(parts.next_attempt, overrides.next_attempt)
             assert.equal(parts.attempts, overrides.attempts)
@@ -75,8 +75,8 @@ describe('qfile', () => {
             assert.equal(parts.host, overrides.host)
         })
 
-        it('handles 4', () => {
-            const r = this.qfile.parts('1484878079415_0_12345_8888.mta1.example.com')
+        it('handles 4-part legacy filename', () => {
+            const r = qfile.parts('1484878079415_0_12345_8888.mta1.example.com')
             delete r.arrival
             delete r.uid
             delete r.counter
@@ -89,8 +89,8 @@ describe('qfile', () => {
             })
         })
 
-        it('handles 7', () => {
-            const r = this.qfile.parts('1516650518128_1516667073032_8_29538_TkPZWz_1_haraka')
+        it('handles 7-part standard filename', () => {
+            const r = qfile.parts('1516650518128_1516667073032_8_29538_TkPZWz_1_haraka')
             delete r.age
             assert.deepEqual(r, {
                 arrival: 1516650518128,
@@ -103,22 +103,22 @@ describe('qfile', () => {
             })
         })
 
-        it('punts on 5', () => {
-            assert.deepEqual(this.qfile.parts('1516650518128_1516667073032_8_29538_TkPZWz'), null)
+        it('punts on 5-part filename', () => {
+            assert.deepEqual(qfile.parts('1516650518128_1516667073032_8_29538_TkPZWz'), null)
         })
     })
 
     describe('hostname', () => {
-        it('hostname, defaults to os.hostname()', () => {
-            assert.deepEqual(this.qfile.hostname(), require('os').hostname())
+        it('defaults to os.hostname()', () => {
+            assert.deepEqual(qfile.hostname(), os.hostname())
         })
 
-        it('hostname, replaces \\ char', () => {
-            assert.deepEqual(this.qfile.hostname('mt\\a1.exam\\ple.com'), 'mt\\057a1.exam\\057ple.com')
+        it('replaces backslash char', () => {
+            assert.deepEqual(qfile.hostname('mt\\a1.exam\\ple.com'), 'mt\\057a1.exam\\057ple.com')
         })
 
-        it('hostname, replaces _ char', () => {
-            assert.deepEqual(this.qfile.hostname('mt_a1.exam_ple.com'), 'mt\\137a1.exam\\137ple.com')
+        it('replaces underscore char', () => {
+            assert.deepEqual(qfile.hostname('mt_a1.exam_ple.com'), 'mt\\137a1.exam\\137ple.com')
         })
     })
 })

package/test/outbound/queue.js

@@ -0,0 +1,233 @@
+'use strict'
+
+const { describe, it, beforeEach, afterEach } = require('node:test')
+const assert = require('node:assert')
+const fs = require('node:fs')
+const path = require('node:path')
+const os = require('node:os')
+
+const queue = require('../../outbound/queue')
+const qfile = require('../../outbound/qfile')
+
+const sourceQueueDir = path.join('test', 'queue')
+const testQueueDir = path.join('test', 'test-queue')
+const fixtureFiles = [
+    '1508455115683_1508455115683_0_90253_9Q4o4V_1_haraka',
+    '1508269674999_1508269674999_0_34002_socVUF_1_haraka',
+]
+
+const clearTestQueue = () => {
+    fs.mkdirSync(testQueueDir, { recursive: true })
+    for (const file of fs.readdirSync(testQueueDir)) {
+        fs.unlinkSync(path.join(testQueueDir, file))
+    }
+}
+
+const populateTestQueue = () => {
+    clearTestQueue()
+    for (const file of fixtureFiles) {
+        fs.copyFileSync(path.join(sourceQueueDir, file), path.join(testQueueDir, file))
+    }
+}
+
+describe('outbound/queue', () => {
+    describe('read_parts', () => {
+        it('parses valid queue filenames', () => {
+            const filename = '1507509981169_1507509981169_0_61403_e0Y0Ym_1_haraka'
+            const parts = queue.read_parts(filename)
+            assert.ok(parts)
+            assert.equal(parts.arrival, 1507509981169)
+            assert.equal(parts.next_attempt, 1507509981169)
+            assert.equal(parts.attempts, 0)
+            assert.equal(parts.pid, 61403)
+            assert.equal(parts.uid, 'e0Y0Ym')
+        })
+
+        it('rejects dot files', () => {
+            assert.strictEqual(queue.read_parts('__tmp__.filename'), false)
+        })
+
+        it('rejects error files', () => {
+            assert.strictEqual(queue.read_parts('error.something'), false)
+        })
+
+        it('rejects invalid queue files', () => {
+            assert.strictEqual(queue.read_parts('invalid-file'), false)
+        })
+    })
+
+    describe('load_queue_files', () => {
+        beforeEach(() => {
+            populateTestQueue()
+        })
+        afterEach(() => {
+            clearTestQueue()
+        })
+
+        it('processes valid queue files', async () => {
+            const seen = []
+
+            const files = await queue.load_queue_files(
+                null,
+                ['1508455115683_1508455115683_0_90253_9Q4o4V_1_haraka'],
+                (file) => {
+                    seen.push(file)
+                    return file
+                },
+            )
+            assert.equal(seen.length, 1)
+            assert.equal(files[0], '1508455115683_1508455115683_0_90253_9Q4o4V_1_haraka')
+        })
+
+        it('skips invalid files', async () => {
+            const seen = []
+
+            await queue.load_queue_files(
+                null,
+                ['1507509981169_1507509981169_0_61403_e0Y0Ym_1_haraka', 'invalid-file', 'zero-length'],
+                (file) => {
+                    seen.push(file)
+                },
+            )
+            assert.equal(seen.length, 1)
+        })
+
+        it('filters files by pid', async () => {
+            let renameAttempts = 0
+
+            const originalRename = queue.rename_to_actual_pid
+            queue.rename_to_actual_pid = (_file, _parts) => {
+                renameAttempts++
+                throw new Error('test skip')
+            }
+
+            await queue.load_queue_files(
+                61403,
+                [
+                    '1507509981169_1507509981169_0_61403_e0Y0Ym_1_haraka',
+                    '1508455115683_1508455115683_0_90253_9Q4o4V_1_haraka',
+                ],
+                (_file) => {},
+            )
+            queue.rename_to_actual_pid = originalRename
+            assert.equal(renameAttempts, 1)
+        })
+    })
+
+    describe('ensure_queue_dir', () => {
+        it('creates queue dir', async () => {
+            const tmpDir = path.join(os.tmpdir(), `haraka-test-queue-${Date.now()}`)
+
+            const originalQueueDir = queue.queue_dir
+            queue.queue_dir = tmpDir
+
+            try {
+                await queue.ensure_queue_dir()
+                assert.ok(fs.existsSync(tmpDir))
+                const stat = await fs.promises.stat(tmpDir)
+                assert.ok(stat.isDirectory())
+            } catch (err) {
+                assert.fail(`ensure_queue_dir threw an error: ${err.message}`)
+            } finally {
+                queue.queue_dir = originalQueueDir
+                if (fs.existsSync(tmpDir)) fs.rmSync(tmpDir, { recursive: true })
+            }
+        })
+
+        it('returns early if queue dir already exists', async () => {
+            const tmpDir = path.join(os.tmpdir(), `haraka-test-queue-exists-${Date.now()}`)
+            fs.mkdirSync(tmpDir)
+
+            const originalQueueDir = queue.queue_dir
+            queue.queue_dir = tmpDir
+
+            try {
+                await queue.ensure_queue_dir()
+                assert.ok(fs.existsSync(tmpDir))
+            } catch (err) {
+                assert.fail(`ensure_queue_dir threw an error: ${err.message}`)
+            } finally {
+                queue.queue_dir = originalQueueDir
+                fs.rmSync(tmpDir, { recursive: true })
+            }
+        })
+    })
+
+    describe('_load_cur_queue', () => {
+        beforeEach(() => {
+            populateTestQueue()
+        })
+        afterEach(() => {
+            clearTestQueue()
+        })
+
+        it('reads queue directory and processes files', async () => {
+            const processedFiles = []
+            await queue._load_cur_queue(null, (file) => {
+                processedFiles.push(file)
+            })
+
+            assert.ok(processedFiles.length >= 0)
+        })
+    })
+
+    describe('list_queue', () => {
+        beforeEach(() => {
+            populateTestQueue()
+        })
+        afterEach(() => {
+            clearTestQueue()
+        })
+
+        it('returns todo objects from real queue files', async () => {
+            const qlist = await queue.list_queue()
+            assert.ok(Array.isArray(qlist))
+            assert.ok(qlist.length > 0)
+            assert.ok(qlist[0].mail_from)
+            assert.ok(Array.isArray(qlist[0].rcpt_to))
+        })
+    })
+
+    describe('stat_queue', () => {
+        beforeEach(() => {
+            populateTestQueue()
+        })
+        afterEach(() => {
+            clearTestQueue()
+        })
+
+        it('returns queue stats', async () => {
+            const stats = await queue.stat_queue()
+            assert.ok(stats)
+            assert.ok('queue_dir' in stats)
+            assert.ok(stats.queue_count >= 1)
+        })
+    })
+
+    describe('load_pid_queue', () => {
+        beforeEach(() => {
+            populateTestQueue()
+        })
+        afterEach(() => {
+            clearTestQueue()
+        })
+
+        it('delegates pid loading to init_queue', async () => {
+            const parts = qfile.parts(fixtureFiles[0])
+            const observed = []
+            const originalLoadQueue = queue.init_queue
+
+            queue.init_queue = (pid) => {
+                observed.push(pid)
+            }
+
+            try {
+                assert.ok(fs.existsSync(path.join(testQueueDir, fixtureFiles[0])))
+                await queue.load_pid_queue(parts.pid)
+                assert.deepEqual(observed, [parts.pid])
+            } finally {
+                queue.init_queue = originalLoadQueue
+            }
+        })
+    })
+})

package/test/plugins/queue/smtp_forward.js

@@ -30,7 +30,7 @@ describe('smtp_forward', () => {
             plugin.register()
 
             assert.equal(plugin.tls_options, undefined)
-            assert.equal(plugin.register_hook.called, true)
+            assert.ok(Object.keys(plugin.hooks).length)
         })
     })
 

package/test/plugins/record_envelope_addresses.js

@@ -0,0 +1,93 @@
+'use strict'
+
+const assert = require('node:assert')
+
+const { Address } = require('address-rfc2821')
+const fixtures = require('haraka-test-fixtures')
+
+const _set_up = (done) => {
+    this.plugin = new fixtures.plugin('record_envelope_addresses')
+    this.connection = fixtures.connection.createConnection()
+    this.connection.init_transaction()
+    done()
+}
+
+describe('record_envelope_addresses', () => {
+    beforeEach(_set_up)
+
+    describe('hook_mail', () => {
+        it('adds X-Envelope-From header from MAIL FROM address', (done) => {
+            const addr = new Address('<sender@example.com>')
+            this.plugin.hook_mail(
+                () => {
+                    const vals = this.connection.transaction.header.get_all('X-Envelope-From')
+                    assert.equal(vals.length, 1, 'header was added')
+                    assert.equal(vals[0], 'sender@example.com')
+                    done()
+                },
+                this.connection,
+                [addr],
+            )
+        })
+
+        it('does not throw when connection has no transaction', (done) => {
+            this.connection.transaction = null
+            const addr = new Address('<sender@example.com>')
+            this.plugin.hook_mail(
+                () => {
+                    assert.ok(true, 'next was called without error')
+                    done()
+                },
+                this.connection,
+                [addr],
+            )
+        })
+    })
+
+    describe('hook_rcpt', () => {
+        it('adds X-Envelope-To header from RCPT TO address', (done) => {
+            const addr = new Address('<rcpt@example.com>')
+            this.plugin.hook_rcpt(
+                () => {
+                    const vals = this.connection.transaction.header.get_all('X-Envelope-To')
+                    assert.equal(vals.length, 1, 'header was added')
+                    assert.equal(vals[0], 'rcpt@example.com')
+                    done()
+                },
+                this.connection,
+                [addr],
+            )
+        })
+
+        it('adds X-Envelope-To header for each recipient', (done) => {
+            const addr1 = new Address('<one@example.com>')
+            const addr2 = new Address('<two@example.com>')
+            let calls = 0
+            const next = () => {
+                calls++
+                if (calls === 2) {
+                    const vals = this.connection.transaction.header.get_all('X-Envelope-To')
+                    assert.equal(vals.length, 2, 'two headers added')
+                    assert.equal(vals[0], 'one@example.com')
+                    assert.equal(vals[1], 'two@example.com')
+                    done()
+                }
+            }
+            this.plugin.hook_rcpt(next, this.connection, [addr1])
+            this.plugin.hook_rcpt(next, this.connection, [addr2])
+        })
+
+        it('does not throw when connection has no transaction', (done) => {
+            this.connection.transaction = null
+            const addr = new Address('<rcpt@example.com>')
+            this.plugin.hook_rcpt(
+                () => {
+                    assert.ok(true, 'next was called without error')
+                    done()
+                },
+                this.connection,
+                [addr],
+            )
+        })
+    })
+})

package/test/plugins/tls.js

@@ -39,9 +39,9 @@ describe('tls', () => {
     })
 
     describe('register', () => {
-        it('with certs, should call register_hook()', () => {
+        it('with certs, should register hooks', () => {
             this.plugin.register()
-            assert.ok(this.plugin.register_hook.called)
+            assert.ok(Object.keys(this.plugin.hooks).length)
         })
     })
 

package/test/plugins/xclient.js

@@ -0,0 +1,137 @@
+'use strict'
+
+const assert = require('node:assert')
+
+const fixtures = require('haraka-test-fixtures')
+
+const _set_up = (done) => {
+    this.plugin = new fixtures.plugin('xclient')
+    this.connection = fixtures.connection.createConnection()
+    this.connection.capabilities = []
+    done()
+}
+
+describe('xclient', () => {
+    beforeEach(_set_up)
+
+    describe('hook_capabilities', () => {
+        it('adds XCLIENT capability for allowed IP (127.0.0.1)', (done) => {
+            this.connection.remote.ip = '127.0.0.1'
+            this.plugin.hook_capabilities(() => {
+                assert.ok(
+                    this.connection.capabilities.some((c) => c.startsWith('XCLIENT')),
+                    'XCLIENT capability added',
+                )
+                done()
+            }, this.connection)
+        })
+
+        it('adds XCLIENT capability for allowed IP (::1)', (done) => {
+            this.connection.remote.ip = '::1'
+            this.plugin.hook_capabilities(() => {
+                assert.ok(
+                    this.connection.capabilities.some((c) => c.startsWith('XCLIENT')),
+                    'XCLIENT capability added for IPv6 loopback',
+                )
+                done()
+            }, this.connection)
+        })
+
+        it('does not add XCLIENT capability for disallowed IP', (done) => {
+            this.connection.remote.ip = '10.0.0.1'
+            this.plugin.hook_capabilities(() => {
+                assert.ok(
+                    !this.connection.capabilities.some((c) => c.startsWith('XCLIENT')),
+                    'XCLIENT capability not added',
+                )
+                done()
+            }, this.connection)
+        })
+    })
+
+    describe('hook_unrecognized_command', () => {
+        it('ignores non-XCLIENT commands', (done) => {
+            this.plugin.hook_unrecognized_command(
+                (code) => {
+                    assert.equal(code, undefined, 'next called with no args')
+                    done()
+                },
+                this.connection,
+                ['EHLO', 'example.com'],
+            )
+        })
+
+        it('denies XCLIENT when transaction is in progress', (done) => {
+            this.connection.init_transaction()
+            this.plugin.hook_unrecognized_command(
+                (code) => {
+                    assert.equal(code, DENY, 'denied with transaction in progress')
+                    done()
+                },
+                this.connection,
+                ['XCLIENT', 'ADDR=127.0.0.1'],
+            )
+        })
+
+        it('denies XCLIENT from disallowed IP', (done) => {
+            this.connection.remote.ip = '10.0.0.1'
+            this.plugin.hook_unrecognized_command(
+                (code) => {
+                    assert.equal(code, DENY, 'denied from non-allowed IP')
+                    done()
+                },
+                this.connection,
+                ['XCLIENT', 'ADDR=127.0.0.2'],
+            )
+        })
+
+        it('denies XCLIENT with no valid IP address', (done) => {
+            this.connection.remote.ip = '127.0.0.1'
+            this.plugin.hook_unrecognized_command(
+                (code) => {
+                    assert.equal(code, DENY, 'denied when no valid ADDR')
+                    done()
+                },
+                this.connection,
+                ['XCLIENT', 'NAME=example.com'],
+            )
+        })
+
+        it('accepts XCLIENT with valid IPv4 ADDR from allowed host', (done) => {
+            this.connection.remote.ip = '127.0.0.1'
+            this.plugin.hook_unrecognized_command(
+                (code) => {
+                    // NEXT_HOOK or undefined (next called) means accepted
+                    assert.ok(code === NEXT_HOOK || code === undefined, 'accepted valid XCLIENT')
+                    done()
+                },
+                this.connection,
+                ['XCLIENT', 'ADDR=1.2.3.4'],
+            )
+        })
+
+        it('accepts XCLIENT with valid IPv6 ADDR from allowed host', (done) => {
+            this.connection.remote.ip = '127.0.0.1'
+            this.plugin.hook_unrecognized_command(
+                (code) => {
+                    assert.ok(code === NEXT_HOOK || code === undefined, 'accepted valid IPv6 XCLIENT')
+                    done()
+                },
+                this.connection,
+                ['XCLIENT', 'ADDR=IPV6:2001:db8::1'],
+            )
+        })
+
+        it('accepts XCLIENT with ADDR and NAME, skipping rdns lookup', (done) => {
+            this.connection.remote.ip = '127.0.0.1'
+            this.plugin.hook_unrecognized_command(
+                (code) => {
+                    assert.equal(code, NEXT_HOOK, 'jumps to connect hook when NAME provided')
+                    done()
+                },
+                this.connection,
+                ['XCLIENT', 'ADDR=1.2.3.4 NAME=example.com'],
+            )
+        })
+    })
+})

package/test/rfc1869.js

@@ -63,4 +63,47 @@ describe('rfc1869', () => {
     it('RCPT TO:<postmaster>', () => {
         _check('RCPT TO:<postmaster>', ['<postmaster>'])
     })
+
+    describe('error cases', () => {
+        const throwCases = [
+            {
+                desc: 'MAIL FROM with space inside angle-bracket address',
+                args: ['mail', 'FROM:<user@dom ain>'],
+            },
+            {
+                desc: 'RCPT TO with syntax error in address (space in address)',
+                args: ['rcpt', 'TO: user @domain bad'],
+            },
+            {
+                desc: 'RCPT TO unknown address (no @ and not postmaster/abuse)',
+                args: ['rcpt', 'TO:unknown'],
+            },
+        ]
+
+        for (const { desc, args } of throwCases) {
+            it(`throws: ${desc}`, () => {
+                assert.throws(() => parse(...args), Error)
+            })
+        }
+    })
+
+    describe('strict mode', () => {
+        it('strict MAIL FROM:<user@domain> accepts angle-bracket address', () => {
+            const result = parse('mail', 'FROM:<user@domain.com>', true)
+            assert.equal(result[0], '<user@domain.com>')
+        })
+
+        it('strict MAIL FROM without angle brackets throws', () => {
+            assert.throws(() => parse('mail', 'FROM:user@domain.com', true), Error)
+        })
+
+        it('strict RCPT TO:<user@domain> accepts angle-bracket address', () => {
+            const result = parse('rcpt', 'TO:<user@domain.com>', true)
+            assert.equal(result[0], '<user@domain.com>')
+        })
+
+        it('strict RCPT TO without angle brackets throws', () => {
+            assert.throws(() => parse('rcpt', 'TO:user@domain.com', true), Error)
+        })
+    })
 })

package/test/smtp_client.js

@@ -140,15 +140,15 @@ describe('smtp_client', () => {
             this.client.on('data', () => {
                 assert.equal(this.client.response[0], 'go ahead')
                 this.client.start_data(message_stream)
-                message_stream.on('end', () => {
-                    this.client.socket.write('.\r\n')
-                })
                 message_stream.add_line('Header: test\r\n')
                 message_stream.add_line('\r\n')
                 message_stream.add_line('hi\r\n')
                 message_stream.add_line_end()
             })
 
+            data.push('Header: test')
+            data.push('')
+            data.push('hi')
             data.push('.')
             data.push('250 message queued')
 
@@ -249,15 +249,15 @@ describe('smtp_client', () => {
             this.client.on('data', () => {
                 assert.equal(this.client.response[0], 'go ahead')
                 this.client.start_data(message_stream)
-                message_stream.on('end', () => {
-                    this.client.socket.write('.\r\n')
-                })
                 message_stream.add_line('Header: test\r\n')
                 message_stream.add_line('\r\n')
                 message_stream.add_line('hi\r\n')
                 message_stream.add_line_end()
             })
 
+            data.push('Header: test')
+            data.push('')
+            data.push('hi')
             data.push('.')
             data.push('250 message queued')