imapflow 1.5.0 → 1.6.1

package/test/imap-flow-compress-test.js

@@ -143,11 +143,23 @@ module.exports['Compress: session negotiates DEFLATE and runs commands'] = async
     client.write(Buffer.alloc(128 * 1024, 0x61));
     await new Promise(r => setTimeout(r, 50));
 
+    // Each stream owns and reports its own lifecycle: the compression PassThrough used to proxy
+    // the raw socket's `destroyed` getter, which made close() skip destroying it.
+    let rawSocket = client.socket;
+    let passThrough = client.writeSocket;
+    test.notEqual(passThrough, rawSocket, 'compression replaced the write socket with a PassThrough');
+    test.equal(passThrough.destroyed, false, 'the PassThrough reports its own state while alive');
+
     await client.logout();
     client.close();
     // close() must tear down the compression streams
     test.ok(!client._deflate, 'deflate cleaned up after close');
     test.ok(!client._inflate, 'inflate cleaned up after close');
+    test.ok(passThrough.destroyed, 'the compression PassThrough was destroyed');
+    test.ok(rawSocket.destroyed, 'the raw socket was destroyed');
+
+    // Repeated close() stays idempotent
+    test.doesNotThrow(() => client.close());
 
     server.close();
     test.done();

package/test/imap-flow-coverage-test.js

@@ -524,7 +524,7 @@ module.exports['Coverage: reader swallows a throwing untagged handler'] = async
 module.exports['Coverage: reader swallows a throwing trySend after a tagged response'] = async test => {
     let client = makeClient();
     let resolved = false;
-    client.currentRequest = { tag: 'A1' };
+    client.currentRequest = { tag: 'A1', sent: true };
     client.requestTagMap.set('A1', {
         command: 'NOOP',
         attributes: [],
@@ -549,7 +549,7 @@ module.exports['Coverage: reader handles compiler failure when building executed
     let client = makeClient();
     let rejected = null;
     // A request whose attributes cannot be compiled -> the executedCommand try/catch is hit
-    client.currentRequest = { tag: 'A1' };
+    client.currentRequest = { tag: 'A1', sent: true };
     client.requestTagMap.set('A1', {
         command: 'NOOP',
         // a circular/odd attribute that makes the logging compiler throw
@@ -576,7 +576,7 @@ module.exports['Coverage: reader handles compiler failure when building executed
 module.exports['Coverage: reader caps very large throttle backoff'] = async test => {
     let client = makeClient();
     let rejected = null;
-    client.currentRequest = { tag: 'A1' };
+    client.currentRequest = { tag: 'A1', sent: true };
     client.requestTagMap.set('A1', {
         command: 'FETCH',
         attributes: [],

package/test/imap-flow-internals-test.js

@@ -38,16 +38,39 @@ module.exports['Internals: emitError routes to upgrade rejector while upgrading'
     client.socket = { destroyed: true, destroy: () => {} };
     client.upgrading = true;
     let rejected = null;
+    // Stands in for the upgrade's settle() helper, which owns clearing `upgrading`,
+    // the upgrade timer and the temporary handshake handlers.
     client._upgradeReject = err => {
         rejected = err;
+        client.upgrading = false;
     };
     let err = new Error('tls boom');
     client.emitError(err);
     test.equal(rejected, err);
+    test.equal(client._upgradeReject, null, 'the rejector is consumed exactly once');
     test.equal(client.upgrading, false);
     test.done();
 };
 
+module.exports['Internals: emitError closes when an upgrade has no rejector'] = test => {
+    let client = makeClient();
+    client.socket = { destroyed: true, destroy: () => {} };
+    client.upgrading = true;
+    client._upgradeReject = null;
+
+    let emitted = false;
+    client.on('error', () => {
+        emitted = true;
+    });
+
+    client.emitError(new Error('tls boom'));
+
+    test.equal(client.upgrading, false, 'the upgrade flag is cleared');
+    test.equal(emitted, false, 'no duplicate error event while the upgrade owns reporting');
+    client.close();
+    test.done();
+};
+
 module.exports['Internals: emitError rejects pending connect promise'] = test => {
     let client = makeClient();
     client.socket = { destroyed: true, destroy: () => {} };

package/test/imap-flow-proxy-paths-test.js

@@ -8,6 +8,7 @@ const net = require('net');
 const tls = require('tls');
 const proxyquire = require('proxyquire');
 const { cert, key } = require('./fixtures/test-tls');
+const { ImapFlow } = require('../lib/imap-flow');
 
 const CAPS = 'IMAP4rev1 ID ENABLE NAMESPACE';
 
@@ -213,3 +214,153 @@ module.exports['Proxy: proxyConnection throwing rejects connect'] = async test =
     client.close();
     test.done();
 };
+
+// ---------------------------------------------------------------------------
+// End to end through a real HTTP CONNECT proxy (ImapFlow's own CONNECT helper)
+// ---------------------------------------------------------------------------
+
+// Minimal HTTP CONNECT proxy. `onConnect(socket, headers)` may take over the exchange (used to
+// simulate a proxy that never answers); otherwise the tunnel is established and piped. With
+// `coalesce`, the 200 response is held back until the destination speaks and then written in the
+// same segment as the destination's greeting - which is what a real proxy often does.
+const createHttpProxy = (onConnect, { coalesce = false } = {}) =>
+    net.createServer(socket => {
+        socket.on('error', () => {});
+        let buf = '';
+        const onData = data => {
+            buf += data.toString('binary');
+            let idx = buf.indexOf('\r\n\r\n');
+            if (idx < 0) {
+                return;
+            }
+            socket.removeListener('data', onData);
+            let headers = buf.slice(0, idx);
+            let rest = buf.slice(idx + 4);
+            let authority = (headers.split('\r\n')[0].match(/^CONNECT (\S+)/) || [])[1] || '';
+
+            if (onConnect && onConnect(socket, headers)) {
+                return;
+            }
+
+            let [, targetPort] = authority.split(':');
+            let upstream = net.connect(Number(targetPort), '127.0.0.1', () => {
+                if (rest) {
+                    upstream.write(Buffer.from(rest, 'binary'));
+                }
+
+                const startTunnel = () => {
+                    socket.pipe(upstream);
+                    upstream.pipe(socket);
+                };
+
+                if (!coalesce) {
+                    socket.write('HTTP/1.1 200 Connection established\r\n\r\n');
+                    return startTunnel();
+                }
+
+                // Hold the CONNECT response until the destination sends something, then emit both
+                // in a single write so the client has to preserve the trailing bytes itself.
+                upstream.once('data', firstChunk => {
+                    socket.write(Buffer.concat([Buffer.from('HTTP/1.1 200 Connection established\r\n\r\n'), firstChunk]));
+                    startTunnel();
+                });
+            });
+            upstream.on('error', () => socket.destroy());
+        };
+        socket.on('data', onData);
+    });
+
+module.exports['Proxy: session established through a real HTTP CONNECT proxy'] = async test => {
+    let imapServer = createServer();
+    let imapPort = await listen(imapServer);
+    let proxy = createHttpProxy();
+    let proxyPort = await listen(proxy);
+
+    let client = new ImapFlow({
+        host: '127.0.0.1',
+        port: imapPort,
+        secure: false,
+        proxy: `http://127.0.0.1:${proxyPort}`,
+        disableAutoIdle: true,
+        disableCompression: true,
+        logger: false,
+        auth: { user: 'test', pass: 'secret' }
+    });
+    client.on('error', () => {});
+
+    await client.connect();
+    test.ok(client.usable, 'session established through the CONNECT tunnel');
+    test.ok(client.authenticated);
+
+    await client.logout();
+    client.close();
+    proxy.close();
+    imapServer.close();
+    test.done();
+};
+
+module.exports['Proxy: a greeting coalesced with the CONNECT response is not lost'] = async test => {
+    // The proxy answers CONNECT and the destination greeting in one segment. The bytes after the
+    // header terminator belong to the tunnel, so they have to reach the parser - otherwise the
+    // greeting is swallowed and connect() only fails at the greeting timeout.
+    let imapServer = createServer();
+    let imapPort = await listen(imapServer);
+    let proxy = createHttpProxy(null, { coalesce: true });
+    let proxyPort = await listen(proxy);
+
+    let client = new ImapFlow({
+        host: '127.0.0.1',
+        port: imapPort,
+        secure: false,
+        proxy: `http://127.0.0.1:${proxyPort}`,
+        greetingTimeout: 1500,
+        disableAutoIdle: true,
+        disableCompression: true,
+        logger: false,
+        auth: { user: 'test', pass: 'secret' }
+    });
+    client.on('error', () => {});
+
+    await client.connect();
+    test.ok(client.usable, 'the coalesced greeting was parsed, so the session came up');
+    test.ok(client.capabilities.has('IMAP4rev1'), 'capabilities from the coalesced greeting are present');
+
+    await client.logout();
+    client.close();
+    proxy.close();
+    imapServer.close();
+    test.done();
+};
+
+module.exports['Proxy: a stalled proxy negotiation is bounded by connectionTimeout'] = async test => {
+    // The proxy accepts the CONNECT request and then goes silent
+    let proxy = createHttpProxy(() => true);
+    let proxyPort = await listen(proxy);
+
+    let client = new ImapFlow({
+        host: '127.0.0.1',
+        port: 143,
+        secure: false,
+        proxy: `http://127.0.0.1:${proxyPort}`,
+        connectionTimeout: 150,
+        disableAutoIdle: true,
+        disableCompression: true,
+        logger: false,
+        auth: { user: 'test', pass: 'secret' }
+    });
+    client.on('error', () => {});
+
+    let started = Date.now();
+    let err = await client.connect().then(
+        () => null,
+        e => e
+    );
+
+    test.ok(err, 'connect rejected instead of hanging in proxy negotiation');
+    test.equal(err.code, 'CONNECT_TIMEOUT', 'the documented connection timeout covers proxy negotiation');
+    test.ok(Date.now() - started < 3000, 'the deadline applied to the proxy phase, not only to the transport');
+
+    client.close();
+    proxy.close();
+    test.done();
+};

package/test/imap-flow-secure-test.js

@@ -135,6 +135,165 @@ module.exports['Secure: STARTTLS upgrade completes a session'] = async test => {
     test.done();
 };
 
+// Builds the STARTTLS happy-path server used by the watchdog and cleanup tests below.
+const createStartTlsServer = () =>
+    net.createServer(rawSocket => {
+        rawSocket.on('error', () => {});
+
+        let detachPlain;
+        detachPlain = lineReader(rawSocket, line => {
+            handleLine(rawSocket, line, () => {
+                detachPlain();
+                let tlsSocket = new tls.TLSSocket(rawSocket, { isServer: true, key, cert });
+                tlsSocket.on('error', () => {});
+                lineReader(tlsSocket, l => handleLine(tlsSocket, l, null, CAPS));
+            });
+        });
+
+        rawSocket.write(`* OK [CAPABILITY ${CAPS} STARTTLS] ready\r\n`);
+    });
+
+// Records every socket that went through configureSocket(), which is the single place the
+// transport options (keepalive + inactivity watchdog) are applied.
+const trackConfiguredSockets = client => {
+    let sockets = [];
+    let original = client.configureSocket.bind(client);
+    client.configureSocket = socket => {
+        sockets.push(socket);
+        return original(socket);
+    };
+    return sockets;
+};
+
+module.exports['Secure: STARTTLS session keeps the inactivity watchdog'] = async test => {
+    // Regression: the inactivity timer was armed on the plain socket only, while the timeout
+    // listener was attached to the TLS socket, so an upgraded session had no watchdog at all
+    // and a dead connection was never noticed.
+    let server = createStartTlsServer();
+    let port = await listen(server);
+    let client = new ImapFlow({
+        host: '127.0.0.1',
+        port,
+        secure: false,
+        doSTARTTLS: true,
+        servername: 'localhost',
+        tls: { rejectUnauthorized: false },
+        socketTimeout: 200,
+        disableAutoIdle: true,
+        disableCompression: true,
+        logger: false,
+        auth: { user: 'test', pass: 'secret' }
+    });
+
+    let errors = [];
+    client.on('error', err => errors.push(err));
+    let closed = new Promise(resolve => client.once('close', resolve));
+    let configured = trackConfiguredSockets(client);
+
+    await client.connect();
+    test.ok(client.secureConnection, 'connection upgraded to TLS');
+    test.equal(configured.length, 2, 'both the plain socket and the upgraded socket are configured');
+    test.equal(client.socket.timeout, 200, 'the upgraded socket carries the configured inactivity timeout');
+    test.equal(configured[0].timeout, 0, 'the superseded plain-socket timer is cleared, not left armed');
+
+    // No traffic from here on: the watchdog has to fire and take the connection down.
+    await closed;
+
+    test.ok(
+        errors.some(err => err.code === 'ETIMEOUT'),
+        'the inactivity watchdog reported a socket timeout'
+    );
+    test.ok(client.isClosed, 'the connection closed after the timeout');
+
+    client.close();
+    server.close();
+    test.done();
+};
+
+module.exports['Secure: STARTTLS leaves no upgrade state behind on success'] = async test => {
+    // Item 8: every terminal path of the upgrade runs through one settlement helper, so after
+    // a successful handshake no timer, rejector, flag or temporary handler survives.
+    let server = createStartTlsServer();
+    let port = await listen(server);
+    let client = new ImapFlow({
+        host: '127.0.0.1',
+        port,
+        secure: false,
+        doSTARTTLS: true,
+        servername: 'localhost',
+        tls: { rejectUnauthorized: false },
+        disableAutoIdle: true,
+        disableCompression: true,
+        logger: false,
+        auth: { user: 'test', pass: 'secret' }
+    });
+    client.on('error', () => {});
+
+    await client.connect();
+
+    test.equal(client.upgrading, false, 'upgrading flag cleared');
+    test.equal(client._upgradeReject, null, 'upgrade rejector cleared');
+    test.equal(client.upgradeTimeout, null, 'upgrade timer cleared');
+    // The handshake-only handler is gone, leaving the generic socket error handler as the single
+    // error path (during the handshake it is the other way round, which is what prevents a
+    // handshake error from firing two handlers at once).
+    test.equal(client.socket.listenerCount('error'), 1, 'the TLS socket keeps exactly one error path');
+
+    await client.logout();
+    client.close();
+    server.close();
+    test.done();
+};
+
+module.exports['Secure: close() during a STARTTLS upgrade settles the upgrade'] = async test => {
+    // The server acknowledges STARTTLS but never performs a handshake. close() has to settle
+    // the pending upgrade instead of leaving the session promise dangling forever.
+    let server = net.createServer(rawSocket => {
+        rawSocket.on('error', () => {});
+        let detach = lineReader(rawSocket, line => {
+            handleLine(rawSocket, line, () => {
+                detach(); // silence: no ServerHello, no data at all
+            });
+        });
+        rawSocket.write(`* OK [CAPABILITY ${CAPS} STARTTLS] ready\r\n`);
+    });
+    let port = await listen(server);
+    let client = new ImapFlow({
+        host: '127.0.0.1',
+        port,
+        secure: false,
+        doSTARTTLS: true,
+        servername: 'localhost',
+        tls: { rejectUnauthorized: false },
+        disableAutoIdle: true,
+        disableCompression: true,
+        logger: false,
+        auth: { user: 'test', pass: 'secret' }
+    });
+    client.on('error', () => {});
+
+    let connectResult = client.connect().then(
+        () => null,
+        err => err
+    );
+
+    // Wait until the upgrade is in flight, then close the connection under it.
+    while (!client.upgrading) {
+        await new Promise(resolve => setTimeout(resolve, 10));
+    }
+    client.close();
+
+    let err = await connectResult;
+    test.ok(err, 'connect rejected rather than hanging on the abandoned upgrade');
+    test.ok(['ClosedAfterConnectText', 'ClosedAfterConnectTLS', 'NoConnection'].includes(err.code), `connect rejected with ${err.code}`);
+    test.equal(client.upgrading, false, 'upgrading flag cleared');
+    test.equal(client._upgradeReject, null, 'upgrade rejector cleared');
+    test.equal(client.upgradeTimeout, null, 'upgrade timer cleared');
+
+    server.close();
+    test.done();
+};
+
 // ---------------------------------------------------------------------------
 // Direct TLS connection
 // ---------------------------------------------------------------------------

package/test/imap-flow-server-test.js

@@ -615,6 +615,43 @@ module.exports['Server: verifyOnly connect lists mailboxes and logs out'] = asyn
     test.done();
 };
 
+module.exports['Server: verifyOnly keeps the authentication result after logging out'] = async test => {
+    // The whole point of verifyOnly is to report whether the credentials work. The mode logs out
+    // before connect() resolves, so if close() cleared `authenticated` the caller would read false
+    // off a connection that had just authenticated, with no later moment to read the real answer.
+    let server = createServer();
+    let port = await listen(server);
+    let client = makeClient(port, { verifyOnly: true, includeMailboxes: true });
+    client.on('error', () => {});
+
+    await client.connect();
+    test.ok(client.authenticated, 'authentication result survives the verifyOnly logout');
+
+    client.close();
+    test.ok(client.authenticated, 'and survives an explicit close as well');
+
+    server.close();
+    test.done();
+};
+
+module.exports['Server: an ordinary session clears the authentication state on close'] = async test => {
+    // The counterpart: for a session that is not verifyOnly, `authenticated` describes live state
+    // and must not survive the connection, or reconnect logic reads it as still signed in.
+    let server = createServer();
+    let port = await listen(server);
+    let client = makeClient(port);
+    client.on('error', () => {});
+
+    await client.connect();
+    test.ok(client.authenticated, 'authenticated while the session is up');
+
+    client.close();
+    test.equal(client.authenticated, false, 'cleared once the session ends');
+
+    server.close();
+    test.done();
+};
+
 module.exports['Server: ID is re-requested after login when first response is sparse'] = async test => {
     let idCalls = 0;
     let server = createServer({
@@ -1103,6 +1140,155 @@ module.exports['Server: proxy connection failure rejects connect'] = async test
     test.done();
 };
 
+module.exports['Server: close clears public session state'] = async test => {
+    // Callers inspect these properties in reconnect logic, so they must not keep describing a
+    // session that is gone.
+    let server = createServer();
+    let port = await listen(server);
+    let client = makeClient(port);
+    client.on('error', () => {});
+
+    let events = [];
+    client.on('mailboxClose', mailbox => events.push({ event: 'mailboxClose', path: mailbox.path }));
+    client.on('close', () => events.push({ event: 'close' }));
+
+    await client.connect();
+    await client.mailboxOpen('INBOX');
+
+    test.ok(client.mailbox, 'a mailbox is selected');
+    test.ok(client.authenticated, 'the session is authenticated');
+    test.ok(client.currentSelectCommand, 'the select command is remembered for polling');
+
+    client.close();
+
+    test.equal(client.mailbox, false, 'mailbox state cleared');
+    test.equal(client.currentSelectCommand, false, 'saved select command cleared');
+    test.equal(client.authenticated, false, 'authentication state cleared');
+    test.equal(client.preCheck, false, 'preCheck cleared');
+    test.equal(client.usable, false, 'connection no longer usable');
+    test.equal(client.idling, false, 'idling cleared');
+    test.equal(client.state, client.states.LOGOUT, 'state is LOGOUT');
+
+    // The selected mailbox transitions to closed exactly once, before 'close'
+    test.deepEqual(events, [{ event: 'mailboxClose', path: 'INBOX' }, { event: 'close' }], 'mailboxClose is emitted once, ahead of close');
+
+    // Repeated close() is idempotent and emits nothing more
+    client.close();
+    client.close();
+    test.equal(events.length, 2, 'no duplicate events from repeated close()');
+
+    server.close();
+    test.done();
+};
+
+module.exports['Server: close without a selected mailbox emits no mailboxClose'] = async test => {
+    let server = createServer();
+    let port = await listen(server);
+    let client = makeClient(port);
+    client.on('error', () => {});
+
+    let mailboxCloseCount = 0;
+    client.on('mailboxClose', () => mailboxCloseCount++);
+
+    await client.connect();
+    client.close();
+
+    test.equal(mailboxCloseCount, 0, 'nothing to close, nothing emitted');
+    server.close();
+    test.done();
+};
+
+module.exports['Server: GETQUOTA fallback releases the parser'] = async test => {
+    // Regression: the GETQUOTA fallback never handed its response back to the reader, so the
+    // parser stayed blocked on its backpressure callback and every later command hung.
+    let server = createServer({
+        capabilities: 'IMAP4rev1 ID ENABLE NAMESPACE QUOTA',
+        handlers: {
+            GETQUOTAROOT(ctx) {
+                // root only, no inline QUOTA response - forces the fallback command
+                ctx.write('* QUOTAROOT "INBOX" "userquota"\r\n');
+                ctx.ok('GETQUOTAROOT completed');
+            },
+            GETQUOTA(ctx) {
+                ctx.write('* QUOTA "userquota" (STORAGE 512 1024)\r\n');
+                ctx.ok('GETQUOTA completed');
+            }
+        }
+    });
+    let port = await listen(server);
+    let client = makeClient(port);
+    client.on('error', () => {});
+
+    await client.connect();
+
+    let quota = await client.getQuota();
+    test.ok(quota, 'quota resolved');
+    test.equal(quota.quotaRoot, 'userquota', 'quota root from the first command');
+    test.equal(quota.storage.usage, 512 * 1024, 'quota usage from the fallback command');
+
+    // The parser must still be live: a following command has to complete.
+    let noopResponse = await client.exec('NOOP', false, {});
+    noopResponse.next();
+    test.ok(noopResponse.response, 'the connection still processes commands after the fallback');
+
+    await client.logout();
+    client.close();
+    server.close();
+    test.done();
+};
+
+module.exports['Server: oversized literal cannot inject protocol'] = async test => {
+    // Response-injection regression. With a lowered maxLiteralSize the parser rejects the
+    // literal, and everything after the marker line is ordinary message content chosen by a
+    // third party. None of it may be parsed: no untagged handler may fire and the forged
+    // tagged completion may not settle the in-flight request.
+    let server = createServer({
+        handlers: {
+            NOOP(ctx) {
+                ctx.write(
+                    `* 1 FETCH (BODY[] {5000}\r\n` + //
+                        `INNOCENT MESSAGE TEXT\r\n` +
+                        `* 9999 EXISTS\r\n` +
+                        `${ctx.tag} OK forged completion\r\n`
+                );
+            }
+        }
+    });
+    let port = await listen(server);
+    let client = makeClient(port, { maxLiteralSize: 1024 });
+
+    let errors = [];
+    let existsEvents = [];
+    client.on('error', err => errors.push(err));
+    client.on('exists', ev => existsEvents.push(ev));
+
+    await client.connect();
+    let mailbox = await client.mailboxOpen('INBOX');
+    test.equal(mailbox.exists, 3, 'mailbox opened with the server reported count');
+
+    let noopErr = null;
+    try {
+        // exec() surfaces the raw command outcome, so a forged tagged completion would show
+        // up here as a resolved request (client.noop() would swallow it into `false`).
+        await client.exec('NOOP', false, {});
+        test.ok(false, 'the forged tagged completion must not resolve the in-flight command');
+    } catch (err) {
+        noopErr = err;
+    }
+
+    test.ok(noopErr, 'the in-flight command rejected instead of accepting injected content');
+    test.deepEqual(existsEvents, [], 'the injected untagged EXISTS never reached an untagged handler');
+    test.ok(
+        errors.some(err => err.code === 'LiteralTooLarge'),
+        'the limit violation is surfaced to the caller'
+    );
+    test.ok(client.isClosed || !client.usable, 'the connection failed closed');
+
+    client.close();
+    server.close();
+    test.done();
+};
+
 module.exports['Server: socket close triggers close handling'] = async test => {
     let server = createServer();
     let port = await listen(server);