Haraka 3.0.2 → 3.0.4

package/smtp_client.js

@@ -7,18 +7,15 @@
 // than a bunch of connections to a single host from the configuration values
 // in "host" and "port" (see host_pool.js).
 
-// node.js builtins
-const events       = require('events');
+const events = require('node:events');
 
-// npm deps
-const ipaddr       = require('ipaddr.js');
-const net_utils    = require('haraka-net-utils');
-const utils        = require('haraka-utils');
+const ipaddr    = require('ipaddr.js');
+const net_utils = require('haraka-net-utils');
+const utils     = require('haraka-utils');
 
-// haraka libs
-const line_socket = require('./line_socket');
-const logger      = require('./logger');
-const HostPool    = require('./host_pool');
+const tls_socket = require('./tls_socket')
+const logger     = require('./logger');
+const HostPool   = require('./host_pool');
 
 const smtp_regexp = /^(\d{3})([ -])(.*)/;
 const STATE = {
@@ -33,7 +30,7 @@ class SMTPClient extends events.EventEmitter {
         super();
         this.uuid = utils.uuid();
         this.connect_timeout = parseInt(opts.connect_timeout) || 30;
-        this.socket = opts.socket || line_socket.connect(opts.port, opts.host);
+        this.socket = opts.socket || this.get_socket(opts)
         this.socket.setTimeout(this.connect_timeout * 1000);
         this.socket.setKeepAlive(true);
         this.state = STATE.IDLE;
@@ -66,7 +63,7 @@ class SMTPClient extends events.EventEmitter {
             if (cont !== ' ') return;
 
             if (client.command === 'auth' || client.authenticating) {
-                logger.loginfo(`SERVER RESPONSE, CLIENT ${client.command}, authenticating=${client.authenticating},code=${code},cont=${cont},msg=${msg}`);
+                logger.info(`SERVER RESPONSE, CLIENT ${client.command}, authenticating=${client.authenticating},code=${code},cont=${cont},msg=${msg}`);
                 if (/^3/.test(code) && (
                     msg === 'VXNlcm5hbWU6' ||
                     msg === 'dXNlcm5hbWU6' // Workaround ill-mannered SMTP servers (namely smtp.163.com)
@@ -79,7 +76,7 @@ class SMTPClient extends events.EventEmitter {
                     return;
                 }
                 if (/^2/.test(code) && client.authenticating) {
-                    logger.loginfo('AUTHENTICATED');
+                    logger.info('AUTHENTICATED');
                     client.authenticating = false;
                     client.authenticated = true;
                     client.emit('auth');
@@ -155,7 +152,7 @@ class SMTPClient extends events.EventEmitter {
             client.socket.setTimeout((opts.idle_timeout || 300) * 1000);
             if (!client.socket.remoteAddress) {
                 // "Value may be undefined if the socket is destroyed"
-                logger.logdebug('socket.remoteAddress undefined');
+                logger.debug('socket.remoteAddress undefined');
                 return;
             }
             client.remote_ip = ipaddr.process(client.socket.remoteAddress).toString();
@@ -184,7 +181,7 @@ class SMTPClient extends events.EventEmitter {
                     default:
                 }
 
-                logger.logdebug(`[smtp_client] ${errMsg} (state=${client.state})`);
+                logger.debug(`[smtp_client] ${errMsg} (state=${client.state})`);
             }
         }
 
@@ -220,7 +217,7 @@ class SMTPClient extends events.EventEmitter {
 
     release () {
         if (this.state === STATE.DESTROYED) return;
-        logger.logdebug(`[smtp_client] ${this.uuid} releasing, state=${this.state}`);
+        logger.debug(`[smtp_client] ${this.uuid} releasing, state=${this.state}`);
 
         [
             'auth',   'bad_code', 'capabilities', 'client_protocol', 'connection-error',
@@ -243,7 +240,7 @@ class SMTPClient extends events.EventEmitter {
     upgrade (tls_options) {
 
         this.socket.upgrade(tls_options, (verified, verifyError, cert, cipher) => {
-            logger.loginfo(`secured:${
+            logger.info(`secured:${
 
                 (cipher) ? ` cipher=${cipher.name} version=${cipher.version}` : ''
             } verified=${verified}${
@@ -263,6 +260,16 @@ class SMTPClient extends events.EventEmitter {
         this.release();
         return true;
     }
+
+    get_socket(opts) {
+        const socket = tls_socket.connect({
+            host: opts.host,
+            port: opts.port,
+            timeout: this.connect_timeout,
+        })
+        net_utils.add_line_processor(socket)
+        return socket
+    }
 }
 
 exports.smtp_client = SMTPClient;
@@ -271,7 +278,7 @@ exports.smtp_client = SMTPClient;
 // used only in testing
 exports.get_client = (server, callback, opts = {}) => {
     const smtp_client = new SMTPClient(opts)
-    logger.logdebug(`[smtp_client] uuid=${smtp_client.uuid} host=${opts.host} port=${opts.port} created`)
+    logger.debug(`[smtp_client] uuid=${smtp_client.uuid} host=${opts.host} port=${opts.port} created`)
     callback(smtp_client)
 }
 
@@ -336,7 +343,7 @@ exports.get_client_plugin = (plugin, connection, c, callback) => {
 
     const hostport = get_hostport(connection, connection.server, c);
     const smtp_client = new SMTPClient(hostport)
-    logger.loginfo(`[smtp_client] uuid=${smtp_client.uuid} host=${hostport.host} port=${hostport.port} created`);
+    logger.info(`[smtp_client] uuid=${smtp_client.uuid} host=${hostport.host} port=${hostport.port} created`);
 
     connection.logdebug(plugin, `Got smtp_client: ${smtp_client.uuid}`);
 
@@ -400,7 +407,7 @@ exports.get_client_plugin = (plugin, connection, c, callback) => {
                 if (!c.auth.user || !c.auth.pass) {
                     throw new Error("Must include auth.user and auth.pass for PLAIN auth.");
                 }
-                logger.logdebug(`[smtp_client] uuid=${smtp_client.uuid} authenticating as "${c.auth.user}"`);
+                logger.debug(`[smtp_client] uuid=${smtp_client.uuid} authenticating as "${c.auth.user}"`);
                 smtp_client.send_command('AUTH', `PLAIN ${utils.base64(`${c.auth.user}\0${c.auth.user}\0${c.auth.pass}`)}`);
                 break;
             case 'cram-md5':
@@ -429,7 +436,7 @@ exports.get_client_plugin = (plugin, connection, c, callback) => {
     // these are the errors thrown when the connection is dead
     smtp_client.on('connection-error', (error) => {
         // error contains e.g. "Error: connect ECONNREFUSE"
-        logger.logerror(`backend failure: ${smtp_client.host}:${smtp_client.port} - ${error}`);
+        logger.error(`backend failure: ${smtp_client.host}:${smtp_client.port} - ${error}`);
         const { host_pool } = connection.server.notes;
         // only exists for if forwarding_host_pool is set in the config
         if (host_pool) {
@@ -465,12 +472,12 @@ function get_hostport (connection, server, cfg) {
         const host = server.notes.host_pool.get_host();
         if (host) return host; // { host: 1.2.3.4, port: 567 }
 
-        logger.logerror('[smtp_client] no backend hosts in pool!');
+        logger.error('[smtp_client] no backend hosts in pool!');
         throw new Error("no backend hosts found in pool!");
     }
 
     if (cfg.host && cfg.port) return { host: cfg.host, port: cfg.port };
 
-    logger.logwarn("[smtp_client] forwarding_host_pool or host and port were not found in config file");
+    logger.warn("[smtp_client] forwarding_host_pool or host and port were not found in config file");
     throw new Error("You must specify either forwarding_host_pool or host and port");
 }

package/{tests → test}/config/plugins

@@ -4,6 +4,4 @@ auth/flat_file
 
 rcpt_to.in_host_list
 
-dkim_verify
-
 queue/discard

package/{tests → test}/config/smtp.ini

@@ -6,4 +6,4 @@ nodes=0
 
 daemonize=false
 
-spool_dir=tests/tmp/queue
+spool_dir=test/tmp/queue

package/test/config/tls/example.com/_.example.com.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCYpxuOx4M2s6sI
+iOEInjet7AcJddg/3uVoqoKRW6iTwAUKnP4CsU1Xe/rMU3wr/UcCs8zzFm7L6/cq
+nbj2Pg1dnEvd5arYFWN59XhWjI6vua2ubZkTwBEEGSgSvwnBGU/9qdrXKTeuq+8C
+BgV+SJzeEAmHEyhCDDT0M9Z1p5TFx0ynkaChy2yjffC2dbiRtK7RAja0I97MmSZL
+ym+bVpY0ucTBNNwSNNh8UhWvWZSvVP92WGd2L72txCyfT333i0u1+SoexnJI7Wvn
+7YUaMNA3HSJ5/JjTW0/rOIZGyrfnjFEs5UmULCs6RZSE0eeEuJVRL+Kd+ncYCMlC
+pmsqeIlHAgMBAAECggEAO0n8LBJVZjOWJDR1opFA8u4PNZ9tpDEATQyctbQx32Df
+FGYxSf5vGaFvoVhzi+pNYEFRQsDdu5okX4ruwcUMD+Wamc6P8mksP7wVRxhEev/U
+80BiCge5FCxpIg7MzRD1voHwG01I8TCaHeEU1R2Cv8TeznWkVzLChm5zxzKVV9Mc
+08eqSxOg6M7wF3RpFpn1sBKch2ZNypu0IU4sP+NlRwxsRs/GBZqnyE/dmqvjHeCg
+izcaji/ev8UdiYqASNZ2zzti9SME8VQebAWb71T6MMic03S9cfA+p3FZbzoYrnbG
+pWf1AEsXiyclf6jaxd7ZV1ho6JbcaGdIPXzHZ5VIsQKBgQDLqg9M2oUBrBjJ31LN
+6OtjvMj9SO5BA5eMS/xC2j5cbb9bn8PV3Lge4IDlRMafZW/FwpAt3S68f81lHi9Y
+KwK7zid8J16XFIEh+E95d0O5WOtdm1EU3T19ky8MbfCEIwcmurUusRZoyCYV/9cX
+1n9pDA3hXZtN1OcoHgOaubc+WwKBgQC/4Uh/KIz11YDcWgSO3Z37vwjh8JTtkjLg
+DHRY0zOR6lzrUh5dT9nNT7TjeNxRk8ypPW5BET7T7NBTsoblN53d/nI2lI/sikg0
+nOzqauXAlAX7s6tI/5LSsGF9OHZaiw7R2+egquIv4zN2Keq3Eq4WbGtcV0jiWFsC
+oaOCXyCshQKBgDh2YCGFX2R0SrcEs9ckIMYY23vk0TCzBzu9ASWjjbBgOLH1G/zZ
+YS4mPXXSWGJuY8tmwkQE0uUtZUsIUEXYPrzETYwM+htWcupxBc998gebkDz2R0dK
+grairGN8wzZO47eoAXz9WWIZQv3MXNxd+hqsXdjB88FjKeakU4l8vUGLAoGAG7/z
+AiDVMgBsoHGMUzUN0giwuixW/Xy1St3CPc5dmO6x/X5k0c3oi97JJFSoWEvtv1QZ
+C+P4mCGZh2E8TQ4cEKzpy6b0oZrmEmXXhZdsHsvJibtUPDxp+Xp0vu1ZgIK34/XP
+q9bK224aVS5+uXdEIg4QAMzGx6VLlDfYM9SaHxkCgYBOXl6pRe6UNhRKCfcbKH5e
+JxwHbIyv2d9cL7yqy2lsYlXPhp7S8ClXChoaP5c6v1wAmY2RwPxP/7a541dzGxG5
+RtUY78HHzKQGyobH55YNTyJq+qEUrP/DH5nhLJNvyV1SO7cpMnIO1p3dvnYawVzW
+q+4Yrrdi6tWFPXnjWTGSjw==
+-----END PRIVATE KEY-----

package/test/config/tls/example.com/example.com.crt

@@ -0,0 +1,25 @@
+-----BEGIN CERTIFICATE-----
+MIIEMTCCAxmgAwIBAgIUel2F7YVWKevz0bTFV4mbjr6ZWbIwDQYJKoZIhvcNAQEL
+BQAwgaYxCzAJBgNVBAYTAlVTMRMwEQYDVQQIDApXYXNoaW5ndG9uMRAwDgYDVQQH
+DAdTZWF0dGxlMR0wGwYDVQQKDBRFeGFtcGxlIFdpZGdldHMgSW5jLjETMBEGA1UE
+CwwKRW1haWwgVGVhbTEWMBQGA1UEAwwNKi5leGFtcGxlLmNvbTEkMCIGCSqGSIb3
+DQEJARYVaGFyYWthLm1haWxAZ21haWwuY29tMCAXDTI0MDUwMjE4MzMwMVoYDzIw
+NTEwOTE3MTgzMzAxWjCBpjELMAkGA1UEBhMCVVMxEzARBgNVBAgMCldhc2hpbmd0
+b24xEDAOBgNVBAcMB1NlYXR0bGUxHTAbBgNVBAoMFEV4YW1wbGUgV2lkZ2V0cyBJ
+bmMuMRMwEQYDVQQLDApFbWFpbCBUZWFtMRYwFAYDVQQDDA0qLmV4YW1wbGUuY29t
+MSQwIgYJKoZIhvcNAQkBFhVoYXJha2EubWFpbEBnbWFpbC5jb20wggEiMA0GCSqG
+SIb3DQEBAQUAA4IBDwAwggEKAoIBAQCYpxuOx4M2s6sIiOEInjet7AcJddg/3uVo
+qoKRW6iTwAUKnP4CsU1Xe/rMU3wr/UcCs8zzFm7L6/cqnbj2Pg1dnEvd5arYFWN5
+9XhWjI6vua2ubZkTwBEEGSgSvwnBGU/9qdrXKTeuq+8CBgV+SJzeEAmHEyhCDDT0
+M9Z1p5TFx0ynkaChy2yjffC2dbiRtK7RAja0I97MmSZLym+bVpY0ucTBNNwSNNh8
+UhWvWZSvVP92WGd2L72txCyfT333i0u1+SoexnJI7Wvn7YUaMNA3HSJ5/JjTW0/r
+OIZGyrfnjFEs5UmULCs6RZSE0eeEuJVRL+Kd+ncYCMlCpmsqeIlHAgMBAAGjUzBR
+MB0GA1UdDgQWBBSuPzKGYEvrv9ZuBlSbpgUYG2/gSjAfBgNVHSMEGDAWgBSuPzKG
+YEvrv9ZuBlSbpgUYG2/gSjAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUA
+A4IBAQCCqek5MhytpmmEjVHxfSrbSBJQ63oDa1AllqpDduWCcZZE60zOZOfrGGRO
+A/JUXlJL5otPuxxJX65dJU57Y+ONbGVp9sFOT2bGrL+uwsqS7L+XyUz281sfgO0o
+wsVZq6NyBVaMvtD5ViXPTZslcIZWygcvDVaUEyQ4ri8wqXNQeCNZiZikfM4U03oH
+9kgW/4IuW28Utmnt9f8vPR5XTHURX20p3Q0xhM74mZRtmldwyO3grfe25S7ZOZ5W
+TFuLfxuftJNl5t1w5CdTZre7BYzbWA+Jg34eNWMiHkHE3lVMCLMqZFb8FY0TOLxw
+7YZFDrLYrA2G/alivbHs7ipj6D7i
+-----END CERTIFICATE-----

package/test/connection.js

@@ -0,0 +1,302 @@
+
+const assert = require('node:assert')
+
+const constants    = require('haraka-constants');
+const DSN          = require('haraka-dsn')
+
+const connection   = require('../connection');
+const Server       = require('../server');
+
+// huge hack here, but plugin tests need constants
+constants.import(global);
+
+const _set_up = (done) => {
+    this.backup = {};
+    const client = {
+        remotePort: null,
+        remoteAddress: null,
+        destroy: () => { true; },
+    };
+    const server = {
+        ip_address: null,
+        address () {
+            return this.ip_address;
+        }
+    }
+    this.connection = connection.createConnection(client, server, Server.cfg);
+    done()
+}
+
+describe('connection', () => {
+
+    describe('connectionRaw', () => {
+        beforeEach(_set_up)
+
+        it('has remote object', () => {
+            assert.deepEqual(this.connection.remote, {
+                ip: null,
+                port: null,
+                host: null,
+                info: null,
+                closed: false,
+                is_private: false,
+                is_local: false
+            });
+        })
+
+        it('has local object', () => {
+            assert.equal(this.connection.local.ip, null);
+            assert.equal(this.connection.local.port, null);
+            assert.ok(this.connection.local.host, this.connection.local.host);
+        })
+
+        it('has tls object', () => {
+            assert.deepEqual(this.connection.tls, {
+                enabled: false,
+                advertised: false,
+                verified: false,
+                cipher: {},
+            });
+        })
+
+        it('get_capabilities', () => {
+            assert.deepEqual([], this.connection.get_capabilities());
+        })
+
+        it('queue_msg, defined', () => {
+            assert.equal(
+                'test message',
+                this.connection.queue_msg(1, 'test message')
+            );
+        })
+
+        it('queue_msg, default deny', () => {
+            assert.equal(
+                'Message denied',
+                this.connection.queue_msg(DENY)
+            );
+            assert.equal(
+                'Message denied',
+                this.connection.queue_msg(DENYDISCONNECT)
+            );
+        })
+
+        it('queue_msg, default denysoft', () => {
+            assert.equal(
+                'Message denied temporarily',
+                this.connection.queue_msg(DENYSOFT)
+            );
+            assert.equal(
+                'Message denied temporarily',
+                this.connection.queue_msg(DENYSOFTDISCONNECT)
+            );
+        })
+
+        it('queue_msg, default else', () => {
+            assert.equal('', this.connection.queue_msg('hello'));
+        })
+
+        it('has normalized connection properties', () => {
+            this.connection.set('remote', 'ip', '172.16.15.1');
+            this.connection.set('hello', 'verb', 'EHLO');
+            this.connection.set('tls', 'enabled', true);
+
+            assert.equal('172.16.15.1', this.connection.remote.ip);
+            assert.equal(null, this.connection.remote.port);
+            assert.equal('EHLO', this.connection.hello.verb);
+            assert.equal(null, this.connection.hello.host);
+            assert.equal(true, this.connection.tls.enabled);
+        })
+
+        it('sets remote.is_private and remote.is_local', () => {
+            assert.equal(false, this.connection.remote.is_private);
+            assert.equal(false, this.connection.remote.is_local);
+        })
+
+        it('has normalized proxy properties, default', () => {
+            assert.equal(false, this.connection.proxy.allowed);
+            assert.equal(null, this.connection.proxy.ip);
+            assert.equal(null, this.connection.proxy.type);
+            assert.equal(null, this.connection.proxy.timer);
+        })
+
+        it('has normalized proxy properties, set', () => {
+            this.connection.set('proxy', 'ip', '172.16.15.1');
+            this.connection.set('proxy', 'type', 'haproxy');
+            this.connection.set('proxy', 'timer', setTimeout(() => {}, 1000));
+            this.connection.set('proxy', 'allowed', true);
+
+            assert.equal(true, this.connection.proxy.allowed);
+            assert.equal('172.16.15.1', this.connection.proxy.ip);
+            assert.ok(this.connection.proxy.timer);
+            assert.equal(this.connection.proxy.type, 'haproxy');
+        })
+    })
+
+    describe('connectionPrivate', () => {
+        beforeEach((done) => {
+            this.backup = {};
+            const client = {
+                remotePort: 2525,
+                remoteAddress: '172.16.15.1',
+                localPort: 25,
+                localAddress: '172.16.15.254',
+                destroy: () => { true; },
+            };
+            const server = {
+                ip_address: '172.16.15.254',
+                address () {
+                    return this.ip_address;
+                }
+            }
+            this.connection = connection.createConnection(client, server, Server.cfg);
+            done()
+        })
+
+        it('sets remote.is_private and remote.is_local', () => {
+            assert.equal(true, this.connection.remote.is_private);
+            assert.equal(false, this.connection.remote.is_local);
+            assert.equal(2525, this.connection.remote.port);
+        })
+    })
+
+
+    describe('connectionLocal', () => {
+        beforeEach((done) => {
+            const client = {
+                remotePort: 2525,
+                remoteAddress: '127.0.0.2',
+                localPort: 25,
+                localAddress: '172.0.0.1',
+                destroy: () => { true; },
+            };
+            const server = {
+                ip_address: '127.0.0.1',
+                address () {
+                    return this.ip_address;
+                }
+            };
+            this.connection = connection.createConnection(client, server, Server.cfg);
+            done();
+        })
+
+        it('sets remote.is_private and remote.is_local', () => {
+            assert.equal(true, this.connection.remote.is_private);
+            assert.equal(true, this.connection.remote.is_local);
+            assert.equal(2525, this.connection.remote.port);
+        })
+    })
+
+
+    describe('get_remote', () => {
+        beforeEach(_set_up)
+
+        it('valid hostname', () => {
+            this.connection.remote.host='a.host.tld'
+            this.connection.remote.ip='172.16.199.198'
+            assert.equal(this.connection.get_remote('host'), 'a.host.tld [172.16.199.198]');
+        })
+
+        it('no hostname', () => {
+            this.connection.remote.ip='172.16.199.198'
+            assert.equal(this.connection.get_remote('host'), '[172.16.199.198]');
+        })
+
+        it('DNSERROR', () => {
+            this.connection.remote.host='DNSERROR'
+            this.connection.remote.ip='172.16.199.198'
+            assert.equal(this.connection.get_remote('host'), '[172.16.199.198]');
+        })
+
+        it('NXDOMAIN', () => {
+            this.connection.remote.host='NXDOMAIN'
+            this.connection.remote.ip='172.16.199.198'
+            assert.equal(this.connection.get_remote('host'), '[172.16.199.198]');
+        })
+
+    })
+
+    describe('local_info', () => {
+        beforeEach(_set_up)
+
+        it('is Haraka/version', () => {
+            assert.ok(/Haraka\/\d.\d/.test(this.connection.local.info), this.connection.local.info);
+        })
+    })
+
+    describe('relaying', () => {
+        beforeEach(_set_up)
+
+        it('sets and gets', () => {
+            assert.equal(this.connection.relaying, false);
+            assert.ok(this.connection.relaying = 'alligators');
+            assert.equal(this.connection.relaying, 'alligators');
+        })
+
+        it('sets and gets in a transaction', () => {
+            assert.equal(this.connection.relaying, false);
+            this.connection.transaction = {};
+            assert.ok(this.connection.relaying = 'crocodiles');
+            assert.equal(this.connection.transaction._relaying, 'crocodiles');
+            assert.equal(this.connection.relaying, 'crocodiles');
+        })
+    })
+
+    describe('get_set', () => {
+        beforeEach(_set_up)
+
+        it('sets single level properties', () => {
+            this.connection.set('encoding', true);
+            assert.ok(this.connection.encoding);
+            assert.ok(this.connection.get('encoding'));
+        })
+
+        it('sets two level deep properties', () => {
+            this.connection.set('local.host', 'test');
+            assert.equal(this.connection.local.host, 'test');
+            assert.equal(this.connection.get('local.host'), 'test');
+        })
+
+        it('sets three level deep properties', () => {
+            this.connection.set('some.fine.example', true);
+            assert.ok(this.connection.some.fine.example);
+            assert.ok(this.connection.get('some.fine.example'));
+        })
+    })
+
+    describe('respond', () => {
+        beforeEach(_set_up)
+
+        it('disconnected returns undefined', () => {
+            this.connection.state = constants.connection.state.DISCONNECTED
+            assert.equal(this.connection.respond(200, 'your lucky day'), undefined);
+            assert.equal(this.connection.respond(550, 'you are jacked'), undefined);
+        })
+
+        it('state=command, 200', () => {
+            assert.equal(this.connection.respond(200, 'you may pass Go'), '200 you may pass Go\r\n');
+        })
+
+        it('DSN 200', () => {
+            assert.equal(
+                this.connection.respond(200, DSN.create(200, 'you may pass Go')),
+                '200 2.0.0 you may pass Go\r\n'
+            );
+        })
+
+        it('DSN 550 create', () => {
+            // note, the DSN code overrides the response code
+            assert.equal(
+                this.connection.respond(450, DSN.create(550, 'This domain is not in use and does not accept mail')),
+                '550 5.0.0 This domain is not in use and does not accept mail\r\n'
+            );
+        })
+
+        it('DSN 550 addr_bad_dest_system', () => {
+            assert.equal(
+                this.connection.respond(550, DSN.addr_bad_dest_system('This domain is not in use and does not accept mail', 550)),
+                '550 5.1.2 This domain is not in use and does not accept mail\r\n'
+            );
+        })
+    })
+})

package/test/endpoint.js

@@ -0,0 +1,94 @@
+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('Default port if only host', () => {
+            assert.deepEqual( endpoint('10.0.0.3', 42), {host:'10.0.0.3', port:42} );
+        })
+
+        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'} );
+        })
+    })
+
+    describe('bind()', () => {
+        beforeEach((done) => {
+            // 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');
+            done();
+        })
+
+        afterEach((done) => {
+            mock.stop('node:fs/promises');
+            done();
+        })
+
+        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],
+                ]);
+        })
+    })
+})

package/{tests → test}/fixtures/line_socket.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const events   = require('events');
+const events   = require('node:events');
 const fixtures = require('haraka-test-fixtures');
 const { stub } = fixtures.stub;