imapkit 4.0.3 → 4.1.1

package/lib/commands/uid store.js

@@ -1,5 +0,0 @@
-'use strict';
-
-const { processStore } = require('./store');
-
-module.exports = (connection, parsed, data, callback) => processStore(true, connection, parsed, data, callback);

package/lib/plugins/compress.js

@@ -1,76 +0,0 @@
-'use strict';
-
-const { states } = require('../command-states');
-const DeflateLayer = require('../deflate-layer');
-
-/**
- * @help Adds COMPRESS=DEFLATE [RFC4978] capability
- * @help Raw DEFLATE in both directions after the tagged OK,
- * @help every burst of responses ends with a sync flush
- */
-
-module.exports = function (server) {
-    server.registerCapability('COMPRESS=DEFLATE');
-
-    const isActive = connection => connection.transport instanceof DeflateLayer && connection.transport.active;
-
-    // RFC 8437 section 4.1: after UNAUTHENTICATE the server ends its compression after the CRLF of
-    // the OK, and the client after the CRLF of the command, so anything it compressed later is dropped
-    server.resetHandlers.push(connection => {
-        if (isActive(connection)) {
-            connection.discardInput();
-            connection.transport.endInput();
-            connection.transport.end();
-        }
-    });
-
-    server.setCommandHandler(
-        'COMPRESS',
-        (connection, parsed, data, callback) => {
-            const args = parsed.attributes || [];
-
-            // RFC 4978 section 5: compress = "COMPRESS" SP algorithm, algorithm = "DEFLATE"
-            if (args.length !== 1 || !args[0] || args[0].type !== 'ATOM') {
-                connection.sendStatus(parsed, data, 'BAD', 'COMPRESS expects a compression mechanism');
-                return callback();
-            }
-
-            if (args[0].value.toUpperCase() !== 'DEFLATE') {
-                connection.sendStatus(parsed, data, 'BAD', 'Unknown compression mechanism');
-                return callback();
-            }
-
-            // RFC 4978 section 3: BAD if COMPRESS is already active, NO is for compression by another
-            // layer, such as TLS, which ImapKit never negotiates. Dovecot answers NO here
-            if (isActive(connection)) {
-                connection.sendStatus(parsed, data, 'BAD', 'DEFLATE active via COMPRESS', 'COMPRESSIONACTIVE');
-                return callback();
-            }
-
-            connection.sendStatus(parsed, data, 'OK', 'DEFLATE active');
-
-            if (connection.transport) {
-                // the layer of an earlier session, it passes data on as is since UNAUTHENTICATE
-                connection.transport.destroy();
-            }
-            // compression starts right after the CRLF of the tagged OK
-            connection.transport = new DeflateLayer({
-                writeRaw: chunk => connection.writeRaw(chunk),
-                onData: chunk => connection.onData(chunk),
-                onError: err => {
-                    // the input can not be decompressed, so there is nothing left to talk about
-                    if (connection.options.debug) {
-                        console.log('COMPRESS error: %s', err.message);
-                    }
-                    connection.sendStatus({ tag: '*' }, false, 'BYE', 'Invalid compressed data', false, 'COMPRESS ERROR');
-                    connection.end();
-                }
-            });
-
-            return callback();
-        },
-        // RFC 4978 section 3: the client MUST NOT send further commands until it has seen the result of COMPRESS.
-        // Those commands would be uncompressed, and after an OK the server expects compressed input
-        { states: states.AUTHENTICATED, noPipelining: true }
-    );
-};

package/lib/plugins/enable.js

@@ -1,155 +0,0 @@
-'use strict';
-
-const { states } = require('../command-states');
-
-/**
- * @help Adds ENABLE capability [RFC5161]
- * @help Plugins that can be enabled (eg. CONDSTORE)
- * @help can be loaded in any order
- */
-
-/**
- * Makes an extension available for ENABLE. Plugins call it whether the ENABLE plugin is loaded before or after them
- *
- * @param {Object} server IMAPServer instance
- * @param {String} name Capability name in the spelling it is advertised in, e.g. "IMAP4rev2"
- */
-function registerEnable(server, name) {
-    server.enableAvailable = server.enableAvailable || [];
-    if (server.enableAvailable.indexOf(name) < 0) {
-        server.enableAvailable.push(name);
-    }
-}
-
-/**
- * Checks if a session has enabled an extension with ENABLE. UNAUTHENTICATE clears the list (RFC 8437 section 4.1)
- *
- * @param {Object} connection IMAP connection
- * @param {String} name Capability name in the spelling it was registered with, see registerEnable
- * @return {Boolean} true if the extension is enabled
- */
-function isEnabled(connection, name) {
-    return !!connection.enabled && connection.enabled.indexOf(name) >= 0;
-}
-
-module.exports = function (server) {
-    server.registerCapability('ENABLE');
-
-    // Shared with plugins that can be enabled, these might be loaded before or after this one
-    server.enableAvailable = server.enableAvailable || [];
-
-    server.connectionHandlers.push(connection => {
-        connection.enabled = connection.enabled || [];
-    });
-
-    // RFC 8437 section 4.1: extensions enabled with ENABLE cease to be enabled after UNAUTHENTICATE
-    server.resetHandlers.push(connection => {
-        connection.enabled = [];
-    });
-
-    server.setCommandHandler(
-        'ENABLE',
-        (connection, parsed, data, callback) => {
-            let capability;
-            let i;
-            let len;
-
-            // RFC 5161 section 3.1: "Clients MUST NOT issue ENABLE once they SELECT/EXAMINE a mailbox".
-            // Servers do not have to check this, ImapKit does to catch the client bug.
-            if (connection.everSelected) {
-                connection.sendStatus(parsed, data, 'BAD', 'ENABLE is not allowed after SELECT or EXAMINE');
-                return callback();
-            }
-
-            if (!parsed.attributes) {
-                connection.send(
-                    {
-                        tag: parsed.tag,
-                        command: 'BAD',
-                        attributes: [
-                            {
-                                type: 'TEXT',
-                                value: 'ENABLE expects capability list'
-                            }
-                        ]
-                    },
-                    'INVALID COMMAND',
-                    parsed,
-                    data
-                );
-                return callback();
-            }
-
-            for (i = 0, len = parsed.attributes.length; i < len; i++) {
-                if (!parsed.attributes[i] || parsed.attributes[i].type !== 'ATOM') {
-                    connection.send(
-                        {
-                            tag: parsed.tag,
-                            command: 'BAD',
-                            attributes: [
-                                {
-                                    type: 'TEXT',
-                                    value: 'Attribute nr ' + (i + 1) + ' is not an ATOM'
-                                }
-                            ]
-                        },
-                        'INVALID COMMAND',
-                        parsed,
-                        data
-                    );
-                    return callback();
-                }
-            }
-
-            // The ENABLED response lists only the extensions enabled by this command
-            // Capability names are matched case-insensitively and listed in the spelling the server advertises them
-            // (`server.enableAvailable`), e.g. "IMAP4rev2", so plugins look them up in `connection.enabled` by that name
-            const enabled = [];
-            for (i = 0, len = parsed.attributes.length; i < len; i++) {
-                const requested = parsed.attributes[i].value.toUpperCase();
-                capability = server.enableAvailable.find(name => name.toUpperCase() === requested);
-                if (capability && connection.enabled.indexOf(capability) < 0) {
-                    connection.enabled.push(capability);
-                    enabled.push(capability);
-                }
-            }
-
-            connection.send(
-                {
-                    tag: '*',
-                    command: 'ENABLED',
-                    attributes: enabled.map(capability => ({
-                        type: 'ATOM',
-                        value: capability
-                    }))
-                },
-                'ENABLED',
-                parsed,
-                data,
-                enabled
-            );
-
-            connection.send(
-                {
-                    tag: parsed.tag,
-                    command: 'OK',
-                    attributes: [
-                        {
-                            type: 'TEXT',
-                            value: 'ENABLE completed'
-                        }
-                    ]
-                },
-                'ENABLE',
-                parsed,
-                data
-            );
-
-            return callback();
-        },
-        { states: states.AUTHENTICATED }
-    );
-};
-
-module.exports.registerEnable = registerEnable;
-module.exports.isEnabled = isEnabled;

package/lib/plugins/id.js

@@ -1,138 +0,0 @@
-'use strict';
-
-const { states } = require('../command-states');
-
-/**
- * @help Adds ID [RFC2971] capability
- */
-
-module.exports = function (server) {
-    // Register capability, always usable
-    server.registerCapability('ID');
-
-    // Add ID command
-    server.setCommandHandler(
-        'ID',
-        (connection, parsed, data, callback) => {
-            // keys are client supplied, so the object has no prototype
-            const clientList = Object.create(null);
-            let serverList = null;
-            let i;
-            let len;
-            let key;
-
-            // Require exactly 1 attribute (NIL or parameter list)
-            if (!parsed.attributes || parsed.attributes.length !== 1) {
-                return sendError('ID expects 1 attribute', connection, parsed, data, callback);
-            }
-            const list = parsed.attributes[0];
-            if ((list && !Array.isArray(list)) || (list && list.length % 2)) {
-                return sendError('ID expects valid parameter list', connection, parsed, data, callback);
-            }
-
-            // RFC 2971 section 3.3: at most 30 field-value pairs
-            if (list && list.length > 60) {
-                return sendError('ID allows at most 30 field-value pairs', connection, parsed, data, callback);
-            }
-
-            // Build client ID object and check validity of the values
-            if (list && list.length) {
-                for (i = 0, len = list.length; i < len; i++) {
-                    if (i % 2 === 0) {
-                        // Handle keys (always strings)
-                        if (list[i] && ['STRING', 'LITERAL'].indexOf(list[i].type) >= 0) {
-                            key = list[i].value;
-                            // RFC 2971 section 3.3: field names are at most 30 octets, case-insensitive and unique
-                            if (key.length > 30) {
-                                return sendError('ID field names can be at most 30 octets', connection, parsed, data, callback);
-                            }
-                            if (Object.keys(clientList).some(existing => existing.toLowerCase() === key.toLowerCase())) {
-                                return sendError('ID field names must not repeat', connection, parsed, data, callback);
-                            }
-                        } else {
-                            return sendError('ID expects valid parameter list', connection, parsed, data, callback);
-                        }
-                    } else {
-                        // Handle values (string or NIL)
-                        if (!list[i] || ['STRING', 'LITERAL'].indexOf(list[i].type) >= 0) {
-                            if (list[i] && list[i].value.length > 1024) {
-                                return sendError('ID values can be at most 1024 octets', connection, parsed, data, callback);
-                            }
-                            clientList[key] = (list[i] && list[i].value) || null;
-                        } else {
-                            return sendError('ID expects valid parameter list', connection, parsed, data, callback);
-                        }
-                    }
-                }
-            }
-
-            // Build response object from server options
-            if (server.options.id) {
-                serverList = [];
-                Object.keys(server.options.id).forEach(key => {
-                    serverList.push({
-                        type: 'STRING',
-                        value: key
-                    });
-                    serverList.push({
-                        type: 'STRING',
-                        value: (server.options.id[key] || '').toString()
-                    });
-                });
-            }
-
-            // Send untagged ID response
-            connection.send(
-                {
-                    tag: '*',
-                    command: 'ID',
-                    attributes: [serverList]
-                },
-                'ID',
-                parsed,
-                data,
-                clientList
-            );
-
-            // Send tagged response
-            connection.send(
-                {
-                    tag: parsed.tag,
-                    command: 'OK',
-                    attributes: [
-                        {
-                            type: 'TEXT',
-                            value: 'ID command completed'
-                        }
-                    ]
-                },
-                'ID',
-                parsed,
-                data,
-                clientList
-            );
-
-            callback();
-        },
-        { states: states.ANY }
-    );
-};
-
-function sendError(message, connection, parsed, data, callback) {
-    connection.send(
-        {
-            tag: parsed.tag,
-            command: 'BAD',
-            attributes: [
-                {
-                    type: 'TEXT',
-                    value: message
-                }
-            ]
-        },
-        'INVALID COMMAND',
-        parsed,
-        data
-    );
-    return callback();
-}

package/lib/plugins/idle.js

@@ -1,105 +0,0 @@
-'use strict';
-
-const { states } = require('../command-states');
-
-/**
- * @help Adds IDLE [RFC2177] capability
- */
-
-module.exports = function (server) {
-    server.registerCapability('IDLE');
-
-    server.setCommandHandler(
-        'IDLE',
-        (connection, parsed, data, callback) => {
-            const idleTimer = setTimeout(
-                () => {
-                    if (connection.socket && !connection.socket.destroyed) {
-                        connection.send(
-                            {
-                                tag: '*',
-                                command: 'BYE',
-                                attributes: [
-                                    {
-                                        type: 'TEXT',
-                                        value: 'IDLE terminated'
-                                    }
-                                ]
-                            },
-                            'IDLE EXPIRED',
-                            parsed,
-                            data
-                        );
-                        connection.end();
-                    }
-                },
-                30 * 60 * 1000
-            );
-            // An idling client should not keep the process alive
-            idleTimer.unref();
-
-            const clearIdleTimer = () => clearTimeout(idleTimer);
-            const socket = connection.socket;
-            if (socket) {
-                socket.once('close', clearIdleTimer);
-            }
-
-            connection.directNotifications = true;
-
-            // Temporarily redirect client input to this function
-            connection.inputHandler = function (str) {
-                clearIdleTimer();
-                if (socket) {
-                    socket.removeListener('close', clearIdleTimer);
-                }
-
-                // Stop listening to any other user input
-                connection.inputHandler = false;
-
-                // Notifications are sent again only while a command is in progress
-                connection.directNotifications = false;
-
-                if (str.toUpperCase() === 'DONE') {
-                    connection.send(
-                        {
-                            tag: parsed.tag,
-                            command: 'OK',
-                            attributes: [
-                                {
-                                    type: 'TEXT',
-                                    value: 'IDLE terminated'
-                                }
-                            ]
-                        },
-                        'IDLE',
-                        parsed,
-                        data
-                    );
-                } else {
-                    connection.send(
-                        {
-                            tag: parsed.tag,
-                            command: 'BAD',
-                            attributes: [
-                                {
-                                    type: 'TEXT',
-                                    value: 'Invalid Idle continuation'
-                                }
-                            ]
-                        },
-                        'INVALID IDLE',
-                        parsed,
-                        data
-                    );
-                }
-            };
-
-            connection.write('+ idling\r\n');
-
-            connection.processNotifications();
-
-            return callback();
-        },
-        { states: states.AUTHENTICATED, noArguments: true }
-    );
-};

package/lib/plugins/logindisabled.js

@@ -1,50 +0,0 @@
-'use strict';
-
-/**
- * @help Disables LOGIN support for unencrypted connections
- */
-
-module.exports = function (server) {
-    server.registerCapability('LOGINDISABLED', connection => {
-        return !connection.secureConnection && connection.state === 'Not Authenticated';
-    });
-
-    // Retrieve actual LOGIN handler
-    // Will be run if conditions are met
-    const oldHandler = server.getCommandHandler('LOGIN');
-
-    // Override LOGIN
-    server.setCommandHandler('LOGIN', (connection, parsed, data, callback) => {
-        // If the connection is unsecure, do not allow LOGIN
-        if (!connection.secureConnection) {
-            connection.send(
-                {
-                    tag: parsed.tag,
-                    command: 'NO',
-                    attributes: [
-                        {
-                            type: 'SECTION',
-                            section: [
-                                {
-                                    type: 'ATOM',
-                                    value: 'PRIVACYREQUIRED'
-                                }
-                            ]
-                        },
-                        {
-                            type: 'TEXT',
-                            value: 'Run STARTTLS first'
-                        }
-                    ]
-                },
-                'LOGIN FAILED',
-                parsed,
-                data
-            );
-            return callback();
-        }
-
-        // Reroute command to actual LOGIN handler
-        oldHandler(connection, parsed, data, callback);
-    });
-};