wildduck/lib/autoreply.js

'use strict';

const MailComposer = require('nodemailer/lib/mail-composer');
const MessageSplitter = require('./message-splitter');
const db = require('./db');
const maildrop = require('./maildrop');

const MAX_AUTOREPLY_INTERVAL = 4 * 24 * 3600 * 1000;

module.exports = (options, callback) => {
    // step 1. check if recipient is valid (non special address)
    // step 2. check if recipient not in cache list
    // step 3. parse headers, check if not automatic message
    // step 4. prepare message with special headers (in-reply-to, references, Auto-Submitted)

    if (!options.sender || /mailer\-daemon/i.test(options.sender)) {
        return callback(null, false);
    }

    let messageHeaders = false;
    let messageSplitter = new MessageSplitter();

    messageSplitter.once('headers', headers => {
        messageHeaders = headers;

        let autoSubmitted = headers.getFirst('Auto-Submitted');
        if (autoSubmitted && autoSubmitted.toLowerCase() !== 'no') {
            // skip automatic messages
            return callback(null, false);
        }
        let precedence = headers.getFirst('Precedence');
        if (precedence && ['list', 'junk', 'bulk'].includes(precedence.toLowerCase())) {
            return callback(null, false);
        }
        let listUnsubscribe = headers.getFirst('List-Unsubscribe');
        if (listUnsubscribe) {
            return callback(null, false);
        }
        let suppressAutoresponse = headers.getFirst('X-Auto-Response-Suppress');
        if (suppressAutoresponse && /OOF|AutoReply/i.test(suppressAutoresponse)) {
            return callback(null, false);
        }

        db.redis
            .multi()
            // delete all old entries
            .zremrangebyscore('war:' + options.user._id, '-inf', Date.now() - MAX_AUTOREPLY_INTERVAL)
            // add enw entry if not present
            .zadd('war:' + options.user._id, 'NX', Date.now(), options.sender)
            .exec((err, response) => {
                if (err) {
                    return callback(null, false);
                }

                if (!response || !response[1]) {
                    // already responded
                    return callback(null, false);
                }

                // check limiting counters
                options.messageHandler.counters.ttlcounter('wda:' + options.user._id, 1, 2000, (err, result) => {
                    if (err || !result.success) {
                        return callback(null, false);
                    }

                    let data = {
                        envelope: {
                            from: '',
                            to: options.sender
                        },
                        from: {
                            name: options.user.name,
                            address: options.recipient
                        },
                        to: options.sender,
                        subject: options.user.autoreply.subject
                            ? 'Auto: ' + options.user.autoreply.subject
                            : {
                                prepared: true,
                                value: 'Auto: Re: ' + headers.getFirst('Subject')
                            },
                        headers: {
                            'Auto-Submitted': 'auto-replied'
                        },
                        inReplyTo: headers.getFirst('Message-ID'),
                        references: (headers.getFirst('Message-ID') + ' ' + headers.getFirst('References')).trim(),
                        text: options.user.autoreply.message
                    };

                    let compiler = new MailComposer(data);
                    let message = maildrop(
                        {
                            from: '',
                            to: options.sender,
                            interface: 'autoreply'
                        },
                        callback
                    );

                    compiler.compile().createReadStream().pipe(message);
                });
            });
    });
    messageSplitter.on('error', () => false);
    messageSplitter.on('data', () => false);
    messageSplitter.on('end', () => false);

    setImmediate(() => {
        let pos = 0;
        let writeNextChunk = () => {
            if (messageHeaders || pos >= options.chunks.length) {
                return messageSplitter.end();
            }
            let chunk = options.chunks[pos++];
            if (!messageSplitter.write(chunk)) {
                return messageSplitter.once('drain', writeNextChunk);
            } else {
                setImmediate(writeNextChunk);
            }
        };
        setImmediate(writeNextChunk);
    });
};