imapkit 0.0.0-stage → 4.0.1

package/lib/commands/handlers/store.js

@@ -0,0 +1,127 @@
+'use strict';
+
+const { normalizeSystemFlag, checkSystemFlags } = require('./flags');
+
+const storeHandlers = {};
+
+module.exports = storeHandlers;
+
+function setFlags(connection, message, flags) {
+    const messageFlags = [];
+    [].concat(flags).forEach(flag => {
+        flag = normalizeSystemFlag(typeof flag === 'string' ? flag : String(flag.value || ''));
+        checkSystemFlags(connection, flag);
+
+        // Ignore if it is not in allowed list and only permament flags are allowed to use
+        if (connection.selectedMailbox.permanentFlags.indexOf(flag) < 0 && !connection.selectedMailbox.allowPermanentFlags) {
+            return;
+        }
+
+        if (messageFlags.indexOf(flag) < 0) {
+            messageFlags.push(flag);
+        }
+    });
+    message.flags = messageFlags;
+    connection.server.rememberFlags(connection.selectedMailbox, messageFlags);
+}
+
+function addFlags(connection, message, flags) {
+    [].concat(flags).forEach(flag => {
+        flag = normalizeSystemFlag(typeof flag === 'string' ? flag : String(flag.value || ''));
+        checkSystemFlags(connection, flag);
+
+        // Ignore if it is not in allowed list and only permament flags are allowed to use
+        if (connection.selectedMailbox.permanentFlags.indexOf(flag) < 0 && !connection.selectedMailbox.allowPermanentFlags) {
+            return;
+        }
+
+        if (message.flags.indexOf(flag) < 0) {
+            message.flags.push(flag);
+        }
+    });
+    connection.server.rememberFlags(connection.selectedMailbox, message.flags);
+}
+
+function removeFlags(connection, message, flags) {
+    [].concat(flags).forEach(flag => {
+        flag = normalizeSystemFlag(typeof flag === 'string' ? flag : String(flag.value || ''));
+        checkSystemFlags(connection, flag);
+
+        if (message.flags.indexOf(flag) >= 0) {
+            for (let i = 0; i < message.flags.length; i++) {
+                if (message.flags[i] === flag) {
+                    message.flags.splice(i, 1);
+                    break;
+                }
+            }
+        }
+    });
+}
+
+function sendUpdate(connection, parsed, data, index, message) {
+    const resp = [
+        {
+            type: 'ATOM',
+            value: 'FLAGS'
+        },
+        connection.getFlags(message).map(flag => {
+            return {
+                type: 'ATOM',
+                value: flag
+            };
+        })
+    ];
+
+    if ((parsed.command || '').toUpperCase() === 'UID STORE') {
+        resp.push({
+            type: 'ATOM',
+            value: 'UID'
+        });
+        resp.push(message.uid);
+    }
+
+    connection.send(
+        {
+            tag: '*',
+            attributes: [
+                index,
+                {
+                    type: 'ATOM',
+                    value: 'FETCH'
+                },
+                resp
+            ]
+        },
+        'FLAG UPDATE',
+        parsed,
+        data,
+        message
+    );
+}
+
+storeHandlers.FLAGS = function (connection, message, flags, index, parsed, data) {
+    setFlags(connection, message, flags);
+    sendUpdate(connection, parsed, data, index, message);
+};
+
+storeHandlers['+FLAGS'] = function (connection, message, flags, index, parsed, data) {
+    addFlags(connection, message, flags);
+    sendUpdate(connection, parsed, data, index, message);
+};
+
+storeHandlers['-FLAGS'] = function (connection, message, flags, index, parsed, data) {
+    removeFlags(connection, message, flags);
+    sendUpdate(connection, parsed, data, index, message);
+};
+
+storeHandlers['FLAGS.SILENT'] = function (connection, message, flags) {
+    setFlags(connection, message, flags);
+};
+
+storeHandlers['+FLAGS.SILENT'] = function (connection, message, flags) {
+    addFlags(connection, message, flags);
+};
+
+storeHandlers['-FLAGS.SILENT'] = function (connection, message, flags) {
+    removeFlags(connection, message, flags);
+};

package/lib/commands/list.js

@@ -0,0 +1,100 @@
+'use strict';
+
+module.exports = function (connection, parsed, data, callback) {
+    let folders;
+
+    if (
+        !parsed.attributes ||
+        parsed.attributes.length !== 2 ||
+        !parsed.attributes[0] ||
+        ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[0].type) < 0 ||
+        !parsed.attributes[1] ||
+        ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[1].type) < 0
+    ) {
+        connection.send(
+            {
+                tag: parsed.tag,
+                command: 'BAD',
+                attributes: [
+                    {
+                        type: 'TEXT',
+                        value: 'LIST expects 2 string arguments'
+                    }
+                ]
+            },
+            'INVALID COMMAND',
+            parsed,
+            data
+        );
+        return callback();
+    }
+
+    if (!parsed.attributes[1].value) {
+        // empty reference lists separator only
+        const namespace = connection.server.storage[parsed.attributes[1].value || connection.server.referenceNamespace];
+        if (namespace) {
+            connection.send(
+                {
+                    tag: '*',
+                    command: 'LIST',
+                    attributes: [
+                        [
+                            {
+                                type: 'ATOM',
+                                value: '\\Noselect'
+                            }
+                        ],
+                        namespace.separator,
+                        ''
+                    ]
+                },
+                'LIST ITEM',
+                parsed,
+                data
+            );
+        }
+    } else {
+        folders = connection.server.matchFolders(parsed.attributes[0].value, parsed.attributes[1].value, path => connection.exportMailboxName(path));
+
+        folders.forEach(folder => {
+            connection.send(
+                {
+                    tag: '*',
+                    command: 'LIST',
+                    attributes: [
+                        folder.flags.map(flag => {
+                            return {
+                                type: 'ATOM',
+                                value: flag
+                            };
+                        }),
+                        connection.server.getSeparator(folder),
+                        connection.exportMailboxName(folder.path)
+                    ]
+                },
+                'LIST ITEM',
+                parsed,
+                data,
+                folder
+            );
+        });
+    }
+
+    connection.send(
+        {
+            tag: parsed.tag,
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'Completed'
+                }
+            ]
+        },
+        'LIST',
+        parsed,
+        data
+    );
+
+    return callback();
+};

package/lib/commands/login.js

@@ -0,0 +1,67 @@
+'use strict';
+
+module.exports = function (connection, parsed, data, callback) {
+    // LOGIN expects 2 string params - username and password
+    if (
+        !parsed.attributes ||
+        parsed.attributes.length !== 2 ||
+        !parsed.attributes[0] ||
+        !parsed.attributes[1] ||
+        ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[0].type) < 0 ||
+        ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[1].type) < 0
+    ) {
+        connection.send(
+            {
+                tag: parsed.tag,
+                command: 'BAD',
+                attributes: [
+                    {
+                        type: 'TEXT',
+                        value: 'LOGIN takes 2 string arguments'
+                    }
+                ]
+            },
+            'INVALID COMMAND',
+            parsed,
+            data
+        );
+        return callback();
+    }
+
+    // User names are unicode strings everywhere (LOGIN, SASL, ACL identifiers). LOGIN does not take UTF-8
+    // user names or passwords, a client MUST use AUTHENTICATE for these (RFC 6855 and RFC 9755 section 5)
+    if (parsed.attributes.some(attr => /[\x80-\xff]/.test(attr.value))) {
+        connection.sendStatus(parsed, data, 'BAD', 'LOGIN does not take UTF-8 user names or passwords, use AUTHENTICATE (RFC 9755 section 5)');
+        return callback();
+    }
+
+    const user = connection.server.getUser(parsed.attributes[0].value);
+
+    if (!user || user.password !== parsed.attributes[1].value) {
+        // RFC 5530 section 3: unknown user or bad password
+        connection.sendStatus(parsed, data, 'NO', 'Login failed: authentication failure', 'AUTHENTICATIONFAILED', 'LOGIN FAILED');
+        return callback();
+    }
+
+    connection.state = 'Authenticated';
+    // the authenticated user, for plugins that tell users apart (e.g. ACL)
+    connection.username = parsed.attributes[0].value;
+
+    connection.send(
+        {
+            tag: parsed.tag,
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'User logged in'
+                }
+            ]
+        },
+        'LOGIN SUCCESS',
+        parsed,
+        data
+    );
+
+    callback();
+};

package/lib/commands/logout.js

@@ -0,0 +1,41 @@
+'use strict';
+
+module.exports = function (connection, parsed, data, callback) {
+    connection.state = 'Logout';
+
+    connection.send(
+        {
+            tag: '*',
+            command: 'BYE',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'LOGOUT received'
+                }
+            ]
+        },
+        'LOGOUT UNTAGGED',
+        parsed,
+        data
+    );
+
+    connection.send(
+        {
+            tag: parsed.tag,
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'Completed'
+                }
+            ]
+        },
+        'LOGOUT COMPLETED',
+        parsed,
+        data
+    );
+
+    connection.end();
+
+    callback();
+};

package/lib/commands/lsub.js

@@ -0,0 +1,87 @@
+'use strict';
+
+module.exports = function (connection, parsed, data, callback) {
+    if (
+        !parsed.attributes ||
+        parsed.attributes.length !== 2 ||
+        !parsed.attributes[0] ||
+        ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[0].type) < 0 ||
+        !parsed.attributes[1] ||
+        ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[1].type) < 0
+    ) {
+        connection.send(
+            {
+                tag: parsed.tag,
+                command: 'BAD',
+                attributes: [
+                    {
+                        type: 'TEXT',
+                        value: 'LSUB expects 2 string arguments'
+                    }
+                ]
+            },
+            'INVALID COMMAND',
+            parsed,
+            data
+        );
+        return callback();
+    }
+
+    const server = connection.server;
+    const match = parsed.attributes[1].value;
+    const folders = server.matchFolders(parsed.attributes[0].value, match, path => connection.exportMailboxName(path), server.getSubscriptionTree());
+
+    folders.forEach(folder => {
+        let flags;
+        if (folder.subscribed) {
+            // the subscription list holds names, a subscribed name is listed even if the mailbox does not exist.
+            // \Noselect has a special meaning in LSUB (RFC 5258 section 3.1), so it is not listed for these
+            flags = folder.flags.filter(flag => flag !== '\\Noselect');
+        } else if (match.substr(-1) === '%') {
+            // RFC 3501 section 6.3.9: with "%" a level that is not subscribed but has subscribed names
+            // below it is listed with \Noselect
+            flags = ['\\Noselect'];
+        } else {
+            return;
+        }
+
+        connection.send(
+            {
+                tag: '*',
+                command: 'LSUB',
+                attributes: [
+                    flags.map(flag => {
+                        return {
+                            type: 'ATOM',
+                            value: flag
+                        };
+                    }),
+                    server.getSeparator(folder),
+                    connection.exportMailboxName(folder.path)
+                ]
+            },
+            'LSUB ITEM',
+            parsed,
+            data,
+            folder
+        );
+    });
+
+    connection.send(
+        {
+            tag: parsed.tag,
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'Completed'
+                }
+            ]
+        },
+        'LSUB',
+        parsed,
+        data
+    );
+
+    return callback();
+};

package/lib/commands/noop.js

@@ -0,0 +1,21 @@
+'use strict';
+
+module.exports = function (connection, parsed, data, callback) {
+    connection.send(
+        {
+            tag: parsed.tag,
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'Completed'
+                }
+            ]
+        },
+        'NOOP completed',
+        parsed,
+        data
+    );
+
+    callback();
+};

package/lib/commands/rename.js

@@ -0,0 +1,102 @@
+'use strict';
+
+module.exports = function (connection, parsed, data, callback) {
+    if (
+        !parsed.attributes ||
+        parsed.attributes.length !== 2 ||
+        !parsed.attributes[0] ||
+        ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[0].type) < 0 ||
+        !parsed.attributes[1] ||
+        ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[1].type) < 0
+    ) {
+        connection.send(
+            {
+                tag: parsed.tag,
+                command: 'BAD',
+                attributes: [
+                    {
+                        type: 'TEXT',
+                        value: 'RENAME expects mailbox source and destination names'
+                    }
+                ]
+            },
+            'INVALID COMMAND',
+            parsed,
+            data
+        );
+        return callback();
+    }
+
+    const source = parsed.attributes[0].value;
+    const destination = parsed.attributes[1].value;
+
+    const server = connection.server;
+    const mailbox = server.getMailbox(source);
+    const target = server.getMailbox(destination);
+
+    const sendError = (code, message) => {
+        connection.sendStatus(parsed, data, 'NO', message, code, 'RENAME FAILED');
+        return callback();
+    };
+
+    // check everything that can be checked up front, so that a failed RENAME never loses the source
+    if (!mailbox || mailbox.flags.indexOf('\\Noselect') >= 0) {
+        return sendError('NONEXISTENT', 'Mailbox does not exist');
+    }
+
+    if (target && target.flags.indexOf('\\Noselect') < 0) {
+        return sendError('ALREADYEXISTS', 'Mailbox already exists');
+    }
+
+    const separator = server.getSeparator(mailbox);
+    if (destination.substr(0, mailbox.path.length + separator.length) === mailbox.path + separator) {
+        return sendError('CANNOT', 'Can not move a mailbox into itself');
+    }
+
+    const oldPath = mailbox.path;
+    let newPath;
+    try {
+        if (source.toUpperCase() === 'INBOX') {
+            // Renaming INBOX moves its messages to the new mailbox and leaves INBOX empty (RFC 3501 section 6.3.5)
+            const newMailbox = server.createMailbox(destination);
+            newPath = newMailbox.path;
+            mailbox.messages.forEach(message => {
+                server.copyMessage(newMailbox, message);
+            });
+            connection.expungeSpecificMessages(mailbox, () => true);
+        } else {
+            server.deleteMailbox(source, true);
+            try {
+                server.createMailbox(destination, mailbox);
+            } catch (E) {
+                // put the source mailbox back where it was
+                server.createMailbox(source, mailbox);
+                server.indexFolders();
+                throw E;
+            }
+            server.indexFolders();
+            newPath = mailbox.path;
+        }
+    } catch (E) {
+        return sendError(E.code, E.message);
+    }
+    server.mailboxChanged('rename', newPath, { oldPath });
+
+    connection.send(
+        {
+            tag: parsed.tag,
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'RENAME completed'
+                }
+            ]
+        },
+        'RENAME',
+        parsed,
+        data,
+        mailbox
+    );
+    return callback();
+};

package/lib/commands/search.js

@@ -0,0 +1,76 @@
+'use strict';
+
+const makeSearch = require('./handlers/search');
+const { criteriaValues, sendSearchError } = makeSearch;
+
+/**
+ * Shared implementation of SEARCH and UID SEARCH
+ *
+ * @param {Boolean} isUid If true, the response lists UIDs instead of sequence numbers
+ */
+function processSearch(isUid, connection, parsed, data, callback) {
+    const command = isUid ? 'UID SEARCH' : 'SEARCH';
+
+    if (!parsed.attributes || !parsed.attributes.length) {
+        connection.send(
+            {
+                tag: parsed.tag,
+                command: 'BAD',
+                attributes: [
+                    {
+                        type: 'TEXT',
+                        value: command + ' expects search criteria, empty query given'
+                    }
+                ]
+            },
+            command + ' FAILED',
+            parsed,
+            data
+        );
+        return callback();
+    }
+
+    let searchResult;
+    try {
+        searchResult = makeSearch(connection, connection.getSessionMessages(), criteriaValues(parsed.attributes));
+    } catch (E) {
+        sendSearchError(connection, parsed, data, E, command + ' FAILED');
+        return callback();
+    }
+
+    // RFC 3501 7.2.5: the SEARCH response is sent even when nothing matched. Plugins get the
+    // search result, so they can extend the response or replace it (e.g. ESEARCH)
+    connection.send(
+        {
+            tag: '*',
+            command: 'SEARCH',
+            attributes: searchResult.list.map(item => {
+                return isUid ? item.uid : searchResult.numbers[item.uid];
+            })
+        },
+        command,
+        parsed,
+        data,
+        searchResult
+    );
+
+    connection.send(
+        {
+            tag: parsed.tag,
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: command + ' completed'
+                }
+            ]
+        },
+        command,
+        parsed,
+        data
+    );
+    return callback();
+}
+
+module.exports = (connection, parsed, data, callback) => processSearch(false, connection, parsed, data, callback);
+module.exports.processSearch = processSearch;