imapkit 0.0.0-stage → 4.0.1

package/lib/commands/select.js

@@ -0,0 +1,289 @@
+'use strict';
+
+module.exports = function (connection, parsed, data, callback) {
+    return selectMailbox(connection, parsed, data, callback, false);
+};
+
+/**
+ * Starts a SELECT or EXAMINE, also one that is going to fail: ENABLE is not allowed once a mailbox has been selected
+ * (RFC 5161 section 3.1), and the selected mailbox gets closed. CLOSED marks where the responses for the new mailbox
+ * start (RFC 7162 section 3.2.11, RFC 9051 sections 6.3.2 and 7.1)
+ *
+ * @param {Object} connection IMAP connection
+ * @param {Object} parsed Parsed command
+ * @param {String} data Raw command
+ */
+function beginSelect(connection, parsed, data) {
+    connection.everSelected = true;
+
+    if (connection.state === 'Selected' && connection.server.closedChecks.some(check => check(connection))) {
+        connection.send(
+            {
+                tag: '*',
+                command: 'OK',
+                attributes: [
+                    { type: 'SECTION', section: [{ type: 'ATOM', value: 'CLOSED' }] },
+                    { type: 'TEXT', value: 'Previous mailbox closed' }
+                ]
+            },
+            'CLOSED',
+            parsed,
+            data
+        );
+    }
+}
+
+/**
+ * Shared implementation of SELECT and EXAMINE
+ *
+ * @param {Boolean} readOnly If true, the mailbox is opened read-only (EXAMINE)
+ */
+function selectMailbox(connection, parsed, data, callback, readOnly) {
+    const command = readOnly ? 'EXAMINE' : 'SELECT';
+
+    if (!parsed.attributes || parsed.attributes.length !== 1 || !parsed.attributes[0] || ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[0].type) < 0) {
+        connection.send(
+            {
+                tag: parsed.tag,
+                command: 'BAD',
+                attributes: [
+                    {
+                        type: 'TEXT',
+                        value: command + ' expects 1 mailbox argument'
+                    }
+                ]
+            },
+            'INVALID COMMAND',
+            parsed,
+            data
+        );
+        return callback();
+    }
+
+    const path = parsed.attributes[0].value;
+
+    beginSelect(connection, parsed, data);
+
+    const mailbox = connection.server.getMailbox(path);
+
+    if (!mailbox || mailbox.flags.indexOf('\\Noselect') >= 0) {
+        // a failed SELECT leaves no mailbox selected (RFC 3501 section 6.3.1)
+        connection.closeMailbox();
+
+        connection.sendStatus(parsed, data, 'NO', 'Mailbox does not exist', 'NONEXISTENT', command + ' FAILED');
+        return callback();
+    }
+
+    connection.state = 'Selected';
+    connection.selectedMailbox = mailbox;
+    connection.readOnly = readOnly;
+
+    connection.notificationQueue = [];
+
+    // \Recent is a session flag: a read-write session takes over the messages
+    // that no other session has seen yet (RFC 3501 section 2.3.2)
+    connection.recent = new Set();
+    mailbox.messages.forEach(message => {
+        if (message.recent) {
+            connection.recent.add(message);
+            if (!readOnly) {
+                delete message.recent;
+            }
+        }
+    });
+
+    const status = connection.server.getStatus(mailbox);
+    const permanentFlags = status.permanentFlags.map(flag => {
+        return {
+            type: 'ATOM',
+            value: flag
+        };
+    });
+
+    connection.send(
+        {
+            tag: '*',
+            command: 'FLAGS',
+            attributes: [permanentFlags]
+        },
+        command + ' FLAGS',
+        parsed,
+        data
+    );
+
+    if (mailbox.allowPermanentFlags) {
+        permanentFlags.push({
+            type: 'TEXT',
+            value: '\\*'
+        });
+    }
+
+    connection.send(
+        {
+            tag: '*',
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'SECTION',
+                    section: [
+                        {
+                            type: 'ATOM',
+                            value: 'PERMANENTFLAGS'
+                        },
+                        // nothing can be changed in a read-only mailbox
+                        readOnly ? [] : permanentFlags
+                    ]
+                },
+                {
+                    type: 'TEXT',
+                    value: readOnly ? 'No permanent flags permitted' : 'Flags permitted'
+                }
+            ]
+        },
+        command + ' PERMANENTFLAGS',
+        parsed,
+        data
+    );
+
+    connection.send(
+        {
+            tag: '*',
+            attributes: [
+                mailbox.messages.length,
+                {
+                    type: 'ATOM',
+                    value: 'EXISTS'
+                }
+            ]
+        },
+        command + ' EXISTS',
+        parsed,
+        data
+    );
+
+    connection.send(
+        {
+            tag: '*',
+            attributes: [
+                connection.recent.size,
+                {
+                    type: 'ATOM',
+                    value: 'RECENT'
+                }
+            ]
+        },
+        command + ' RECENT',
+        parsed,
+        data
+    );
+
+    const firstUnseen = mailbox.messages.findIndex(message => message.flags.indexOf('\\Seen') < 0);
+    if (firstUnseen >= 0) {
+        connection.send(
+            {
+                tag: '*',
+                command: 'OK',
+                attributes: [
+                    {
+                        type: 'SECTION',
+                        section: [
+                            {
+                                type: 'ATOM',
+                                value: 'UNSEEN'
+                            },
+                            firstUnseen + 1
+                        ]
+                    },
+                    {
+                        type: 'TEXT',
+                        value: 'First unseen message'
+                    }
+                ]
+            },
+            command + ' UNSEEN',
+            parsed,
+            data
+        );
+    }
+
+    connection.send(
+        {
+            tag: '*',
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'SECTION',
+                    section: [
+                        {
+                            type: 'ATOM',
+                            value: 'UIDVALIDITY'
+                        },
+                        mailbox.uidvalidity
+                    ]
+                },
+                {
+                    type: 'TEXT',
+                    value: 'UIDs valid'
+                }
+            ]
+        },
+        command + ' UIDVALIDITY',
+        parsed,
+        data
+    );
+
+    connection.send(
+        {
+            tag: '*',
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'SECTION',
+                    section: [
+                        {
+                            type: 'ATOM',
+                            value: 'UIDNEXT'
+                        },
+                        mailbox.uidnext
+                    ]
+                },
+                {
+                    type: 'TEXT',
+                    value: 'Predicted next UID'
+                }
+            ]
+        },
+        command + ' UIDNEXT',
+        parsed,
+        data
+    );
+
+    connection.send(
+        {
+            tag: parsed.tag,
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'SECTION',
+                    section: [
+                        {
+                            type: 'ATOM',
+                            value: readOnly ? 'READ-ONLY' : 'READ-WRITE'
+                        }
+                    ]
+                },
+                {
+                    type: 'TEXT',
+                    value: 'Completed'
+                }
+            ]
+        },
+        command,
+        parsed,
+        data
+    );
+    return callback();
+}
+
+module.exports.selectMailbox = selectMailbox;
+module.exports.beginSelect = beginSelect;

package/lib/commands/status.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const { parseStatusItems, sendStatus } = require('./handlers/status');
+
+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 ||
+        !Array.isArray(parsed.attributes[1]) ||
+        !parsed.attributes[1].length
+    ) {
+        connection.send(
+            {
+                tag: parsed.tag,
+                command: 'BAD',
+                attributes: [
+                    {
+                        type: 'TEXT',
+                        value: 'STATUS expects mailbox argument and a list of status items'
+                    }
+                ]
+            },
+            'INVALID COMMAND',
+            parsed,
+            data
+        );
+        return callback();
+    }
+
+    const path = parsed.attributes[0].value;
+
+    // invalid arguments are BAD even for a mailbox that does not exist
+    let items;
+    try {
+        items = parseStatusItems(connection.server, parsed.attributes[1], connection);
+    } catch (err) {
+        connection.sendStatus(parsed, data, 'BAD', err.message, false, 'STATUS FAILED');
+        return callback();
+    }
+
+    const mailbox = connection.server.getMailbox(path);
+
+    if (!mailbox || mailbox.flags.indexOf('\\Noselect') >= 0) {
+        connection.sendStatus(parsed, data, 'NO', 'Mailbox does not exist', 'NONEXISTENT', 'STATUS FAILED');
+        return callback();
+    }
+
+    sendStatus(connection, path, mailbox, items, parsed, data);
+
+    // RFC 3501 section 6.3.10 and RFC 9051 section 6.3.11: STATUS SHOULD NOT be used on the selected mailbox. It
+    // works, but the client gets the CLIENTBUG response code (RFC 5530 section 3) like RFC 9051 section 7.1 shows
+    const clientBug = connection.state === 'Selected' && connection.selectedMailbox === mailbox;
+    connection.sendStatus(
+        parsed,
+        data,
+        'OK',
+        clientBug ? 'Status completed, STATUS SHOULD NOT be used on the selected mailbox' : 'Status completed',
+        clientBug && 'CLIENTBUG'
+    );
+    return callback();
+};

package/lib/commands/store.js

@@ -0,0 +1,151 @@
+'use strict';
+
+const storeHandlers = require('./handlers/store');
+const { restoreNilAtoms, isAtom } = require('../arguments');
+
+/**
+ * Returns the handler of a STORE data item, plugins first
+ *
+ * @param {Object} connection IMAP connection
+ * @param {String} name Data item name, e.g. "+FLAGS.SILENT"
+ * @return {Function|undefined} handler
+ */
+function getStoreHandler(connection, name) {
+    name = String(name).toUpperCase();
+    return connection.server.storeHandlers[name] || storeHandlers[name];
+}
+
+/**
+ * Shared implementation of STORE and UID STORE
+ *
+ * @param {Boolean} isUid If true, the sequence set lists UIDs
+ */
+function processStore(isUid, connection, parsed, data, callback) {
+    const command = isUid ? 'UID STORE' : 'STORE';
+
+    // a store handler with `astringValues` takes astrings, like the labels of X-GM-LABELS: these can be literals,
+    // and NIL is a name there. Flags are atoms (RFC 3501 section 9: flag-list)
+    const itemArgument = parsed.attributes && parsed.attributes[1];
+    const itemHandler = isAtom(itemArgument) && getStoreHandler(connection, itemArgument.value);
+    const astringValues = !!(itemHandler && itemHandler.astringValues);
+    const valueTypes = astringValues ? ['ATOM', 'STRING', 'LITERAL'] : ['ATOM', 'STRING'];
+    if (astringValues) {
+        restoreNilAtoms(parsed, data, path => path[0] === 2);
+    }
+
+    if (
+        !parsed.attributes ||
+        parsed.attributes.length !== 3 ||
+        !parsed.attributes[0] ||
+        ['ATOM', 'SEQUENCE'].indexOf(parsed.attributes[0].type) < 0 ||
+        !parsed.attributes[1] ||
+        ['ATOM'].indexOf(parsed.attributes[1].type) < 0 ||
+        !parsed.attributes[2] ||
+        !(valueTypes.indexOf(parsed.attributes[2].type) >= 0 || Array.isArray(parsed.attributes[2]))
+    ) {
+        connection.send(
+            {
+                tag: parsed.tag,
+                command: 'BAD',
+                attributes: [
+                    {
+                        type: 'TEXT',
+                        value: command + ' expects sequence set, item name and item value'
+                    }
+                ]
+            },
+            'INVALID COMMAND',
+            parsed,
+            data
+        );
+        return callback();
+    }
+
+    // A mailbox opened with EXAMINE is read-only (RFC 3501 6.3.2), so its flags can not be changed
+    if (connection.refuseReadOnly(parsed, data, command + ' FAILED')) {
+        return callback();
+    }
+
+    const range = connection.limitRange(parsed, connection.getCommandRange(parsed.attributes[0].value, isUid));
+    const itemName = (parsed.attributes[1].value || '').toUpperCase();
+    const itemValue = [].concat(parsed.attributes[2] || []);
+    const affected = [];
+    // if the sequence set includes a message that another session expunged without this session being told yet
+    let hasExpunged = false;
+
+    try {
+        itemValue.forEach((item, i) => {
+            if (!item || valueTypes.indexOf(item.type) < 0) {
+                throw new Error('Invalid item value #' + (i + 1));
+            }
+        });
+
+        const handler = itemHandler || getStoreHandler(connection, itemName);
+        if (!handler) {
+            throw new Error('Invalid STORE argument ' + itemName);
+        }
+
+        range.forEach(rangeMessage => {
+            if (rangeMessage[1].ghost) {
+                // RFC 2180 section 4.2: the flags of an expunged message are not stored
+                hasExpunged = true;
+                return;
+            }
+
+            for (let i = 0, len = connection.server.storeFilters.length; i < len; i++) {
+                if (!connection.server.storeFilters[i](connection, rangeMessage[1], parsed, rangeMessage[0])) {
+                    return;
+                }
+            }
+
+            handler(connection, rangeMessage[1], itemValue, rangeMessage[0], parsed, data);
+
+            affected.push(rangeMessage[1]);
+        });
+    } catch (E) {
+        connection.send(
+            {
+                tag: parsed.tag,
+                command: 'BAD',
+                attributes: [
+                    {
+                        type: 'TEXT',
+                        value: E.message
+                    }
+                ]
+            },
+            command + ' FAILED',
+            parsed,
+            data
+        );
+        return callback();
+    }
+
+    // RFC 2180 sections 4.2.2 and 4.2.3: when the set includes expunged messages, the others are stored and get
+    // their FETCH responses, and the tagged NO tells the client to issue NOOP. With .SILENT the result is OK as
+    // long as the other messages were stored (section 4.2.1)
+    const failed = hasExpunged && !/\.SILENT$/.test(itemName);
+
+    connection.send(
+        {
+            tag: parsed.tag,
+            command: failed ? 'NO' : 'OK',
+            attributes: [].concat(failed ? { type: 'SECTION', section: [{ type: 'ATOM', value: 'EXPUNGEISSUED' }] } : [], {
+                type: 'TEXT',
+                value: failed ? 'Some of the messages no longer exist' : command + ' completed'
+            })
+        },
+        command + (failed ? ' FAILED' : ' COMPLETE'),
+        parsed,
+        data,
+        affected
+    );
+
+    // other sessions that have the mailbox selected learn about the new flags (RFC 3501 section 5.2)
+    connection.notifyFlagChanges(affected);
+
+    callback();
+}
+
+module.exports = (connection, parsed, data, callback) => processStore(false, connection, parsed, data, callback);
+module.exports.processStore = processStore;

package/lib/commands/subscribe.js

@@ -0,0 +1,53 @@
+'use strict';
+
+module.exports = function (connection, parsed, data, callback) {
+    if (!parsed.attributes || parsed.attributes.length !== 1 || !parsed.attributes[0] || ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[0].type) < 0) {
+        connection.send(
+            {
+                tag: parsed.tag,
+                command: 'BAD',
+                attributes: [
+                    {
+                        type: 'TEXT',
+                        value: 'SUBSCRIBE expects mailbox name'
+                    }
+                ]
+            },
+            'INVALID COMMAND',
+            parsed,
+            data
+        );
+        return callback();
+    }
+
+    const path = parsed.attributes[0].value;
+
+    const mailbox = connection.server.getMailbox(path);
+
+    if (!mailbox || mailbox.flags.indexOf('\\Noselect') >= 0) {
+        connection.sendStatus(parsed, data, 'NO', 'Mailbox does not exist', 'NONEXISTENT', 'SUBSCRIBE FAILED');
+        return callback();
+    }
+
+    if (!mailbox.subscribed) {
+        mailbox.subscribed = true;
+        connection.server.mailboxChanged('subscribe', mailbox.path);
+    }
+
+    connection.send(
+        {
+            tag: parsed.tag,
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'SUBSCRIBE completed'
+                }
+            ]
+        },
+        'SUBSCRIBE',
+        parsed,
+        data
+    );
+    return callback();
+};

package/lib/commands/uid copy.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const { copyMessages } = require('./copy');
+
+module.exports = function (connection, parsed, data, callback) {
+    return copyMessages(connection, parsed, data, callback, true);
+};

package/lib/commands/uid fetch.js

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

package/lib/commands/uid search.js

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

package/lib/commands/uid store.js

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

package/lib/commands/unsubscribe.js

@@ -0,0 +1,50 @@
+'use strict';
+
+module.exports = function (connection, parsed, data, callback) {
+    if (!parsed.attributes || parsed.attributes.length !== 1 || !parsed.attributes[0] || ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[0].type) < 0) {
+        connection.send(
+            {
+                tag: parsed.tag,
+                command: 'BAD',
+                attributes: [
+                    {
+                        type: 'TEXT',
+                        value: 'UNSUBSCRIBE expects mailbox name'
+                    }
+                ]
+            },
+            'INVALID COMMAND',
+            parsed,
+            data
+        );
+        return callback();
+    }
+
+    let path = parsed.attributes[0].value;
+    if (path.toUpperCase() === 'INBOX') {
+        path = 'INBOX';
+    }
+
+    // The subscription list holds names, so a name stays removable after its mailbox is deleted
+    // (RFC 3501 section 6.3.6). Removing a name that is not subscribed is not an error (RFC 9051 section 6.3.8)
+    if (connection.server.subscriptions.delete(path)) {
+        connection.server.mailboxChanged('unsubscribe', path);
+    }
+
+    connection.send(
+        {
+            tag: parsed.tag,
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'UNSUBSCRIBE completed'
+                }
+            ]
+        },
+        'UNSUBSCRIBE',
+        parsed,
+        data
+    );
+    return callback();
+};