@zone-eu/mailsplit 5.4.6

package/lib/mime-node.js

@@ -0,0 +1,265 @@
+'use strict';
+
+const Headers = require('./headers');
+const libmime = require('libmime');
+const libqp = require('libqp');
+const libbase64 = require('libbase64');
+const PassThrough = require('stream').PassThrough;
+const pathlib = require('path');
+
+class MimeNode {
+    constructor(parentNode, config) {
+        this.type = 'node';
+        this.root = !parentNode;
+        this.parentNode = parentNode;
+
+        this._parentBoundary = this.parentNode && this.parentNode._boundary;
+        this._headersLines = [];
+        this._headerlen = 0;
+
+        this._parsedContentType = false;
+        this._boundary = false;
+
+        this.multipart = false;
+        this.encoding = false;
+        this.headers = false;
+        this.contentType = false;
+        this.flowed = false;
+        this.delSp = false;
+
+        this.config = config || {};
+        this.libmime = new libmime.Libmime({ Iconv: this.config.Iconv });
+
+        this.parentPartNumber = (parentNode && this.partNr) || [];
+        this.partNr = false; // resolved later
+        this.childPartNumbers = 0;
+    }
+
+    getPartNr(provided) {
+        if (provided) {
+            return []
+                .concat(this.partNr || [])
+                .filter(nr => !isNaN(nr))
+                .concat(provided);
+        }
+        let childPartNr = ++this.childPartNumbers;
+        return []
+            .concat(this.partNr || [])
+            .filter(nr => !isNaN(nr))
+            .concat(childPartNr);
+    }
+
+    addHeaderChunk(line) {
+        if (!line) {
+            return;
+        }
+        this._headersLines.push(line);
+        this._headerlen += line.length;
+    }
+
+    parseHeaders() {
+        if (this.headers) {
+            return;
+        }
+        this.headers = new Headers(Buffer.concat(this._headersLines, this._headerlen), this.config);
+
+        this._parsedContentDisposition = this.libmime.parseHeaderValue(this.headers.getFirst('Content-Disposition'));
+
+        // if content-type is missing default to plaintext
+        let contentHeader;
+        if (this.headers.get('Content-Type').length) {
+            contentHeader = this.headers.getFirst('Content-Type');
+        } else {
+            if (this._parsedContentDisposition.params.filename) {
+                let extension = pathlib.parse(this._parsedContentDisposition.params.filename).ext.replace(/^\./, '');
+                if (extension) {
+                    contentHeader = libmime.detectMimeType(extension);
+                }
+            }
+            if (!contentHeader) {
+                if (/^attachment$/i.test(this._parsedContentDisposition.value)) {
+                    contentHeader = 'application/octet-stream';
+                } else {
+                    contentHeader = 'text/plain';
+                }
+            }
+        }
+
+        this._parsedContentType = this.libmime.parseHeaderValue(contentHeader);
+
+        this.encoding = this.headers
+            .getFirst('Content-Transfer-Encoding')
+            .replace(/\(.*\)/g, '')
+            .toLowerCase()
+            .trim();
+        this.contentType = (this._parsedContentType.value || '').toLowerCase().trim() || false;
+        this.charset = this._parsedContentType.params.charset || false;
+        this.disposition = (this._parsedContentDisposition.value || '').toLowerCase().trim() || false;
+
+        // fix invalidly encoded disposition values
+        if (this.disposition) {
+            try {
+                this.disposition = this.libmime.decodeWords(this.disposition);
+            } catch (E) {
+                // failed to parse disposition, keep as is (most probably an unknown charset is used)
+            }
+        }
+
+        this.filename = this._parsedContentDisposition.params.filename || this._parsedContentType.params.name || false;
+
+        if (this._parsedContentType.params.format && this._parsedContentType.params.format.toLowerCase().trim() === 'flowed') {
+            this.flowed = true;
+            if (this._parsedContentType.params.delsp && this._parsedContentType.params.delsp.toLowerCase().trim() === 'yes') {
+                this.delSp = true;
+            }
+        }
+
+        if (this.filename) {
+            try {
+                this.filename = this.libmime.decodeWords(this.filename);
+            } catch (E) {
+                // failed to parse filename, keep as is (most probably an unknown charset is used)
+            }
+        }
+
+        this.multipart =
+            (this.contentType &&
+                this.contentType.substr(0, this.contentType.indexOf('/')) === 'multipart' &&
+                this.contentType.substr(this.contentType.indexOf('/') + 1)) ||
+            false;
+        this._boundary = (this._parsedContentType.params.boundary && Buffer.from(this._parsedContentType.params.boundary)) || false;
+
+        this.rfc822 = this.contentType === 'message/rfc822';
+
+        if (!this.parentNode || this.parentNode.rfc822) {
+            this.partNr = this.parentNode ? this.parentNode.getPartNr('TEXT') : ['TEXT'];
+        } else {
+            this.partNr = this.parentNode ? this.parentNode.getPartNr() : [];
+        }
+    }
+
+    getHeaders() {
+        if (!this.headers) {
+            this.parseHeaders();
+        }
+        return this.headers.build();
+    }
+
+    setContentType(contentType) {
+        if (!this.headers) {
+            this.parseHeaders();
+        }
+
+        contentType = (contentType || '').toLowerCase().trim();
+        if (contentType) {
+            this._parsedContentType.value = contentType;
+        }
+
+        if (!this.flowed && this._parsedContentType.params.format) {
+            delete this._parsedContentType.params.format;
+        }
+
+        if (!this.delSp && this._parsedContentType.params.delsp) {
+            delete this._parsedContentType.params.delsp;
+        }
+
+        this.headers.update('Content-Type', this.libmime.buildHeaderValue(this._parsedContentType));
+    }
+
+    setCharset(charset) {
+        if (!this.headers) {
+            this.parseHeaders();
+        }
+
+        charset = (charset || '').toLowerCase().trim();
+
+        if (charset === 'ascii') {
+            charset = '';
+        }
+
+        if (!charset) {
+            if (!this._parsedContentType.value) {
+                // nothing to set or update
+                return;
+            }
+            delete this._parsedContentType.params.charset;
+        } else {
+            this._parsedContentType.params.charset = charset;
+        }
+
+        if (!this._parsedContentType.value) {
+            this._parsedContentType.value = 'text/plain';
+        }
+
+        this.headers.update('Content-Type', this.libmime.buildHeaderValue(this._parsedContentType));
+    }
+
+    setFilename(filename) {
+        if (!this.headers) {
+            this.parseHeaders();
+        }
+
+        this.filename = (filename || '').toLowerCase().trim();
+
+        if (this._parsedContentType.params.name) {
+            delete this._parsedContentType.params.name;
+            this.headers.update('Content-Type', this.libmime.buildHeaderValue(this._parsedContentType));
+        }
+
+        if (!this.filename) {
+            if (!this._parsedContentDisposition.value) {
+                // nothing to set or update
+                return;
+            }
+            delete this._parsedContentDisposition.params.filename;
+        } else {
+            this._parsedContentDisposition.params.filename = this.filename;
+        }
+
+        if (!this._parsedContentDisposition.value) {
+            this._parsedContentDisposition.value = 'attachment';
+        }
+
+        this.headers.update('Content-Disposition', this.libmime.buildHeaderValue(this._parsedContentDisposition));
+    }
+
+    getDecoder() {
+        if (!this.headers) {
+            this.parseHeaders();
+        }
+
+        switch (this.encoding) {
+            case 'base64':
+                return new libbase64.Decoder();
+            case 'quoted-printable':
+                return new libqp.Decoder();
+            default:
+                return new PassThrough();
+        }
+    }
+
+    getEncoder(encoding) {
+        if (!this.headers) {
+            this.parseHeaders();
+        }
+
+        encoding = (encoding || '').toString().toLowerCase().trim();
+
+        if (encoding && encoding !== this.encoding) {
+            this.headers.update('Content-Transfer-Encoding', encoding);
+        } else {
+            encoding = this.encoding;
+        }
+
+        switch (encoding) {
+            case 'base64':
+                return new libbase64.Encoder();
+            case 'quoted-printable':
+                return new libqp.Encoder();
+            default:
+                return new PassThrough();
+        }
+    }
+}
+
+module.exports = MimeNode;

package/lib/node-rewriter.js

@@ -0,0 +1,194 @@
+'use strict';
+
+// Helper class to rewrite nodes with specific mime type
+
+const Transform = require('stream').Transform;
+const FlowedDecoder = require('./flowed-decoder');
+
+/**
+ * NodeRewriter Transform stream. Updates content for all nodes with specified mime type
+ *
+ * @constructor
+ * @param {String} mimeType Define the Mime-Type to look for
+ * @param {Function} rewriteAction Function to run with the node content
+ */
+class NodeRewriter extends Transform {
+    constructor(filterFunc, rewriteAction) {
+        let options = {
+            readableObjectMode: true,
+            writableObjectMode: true
+        };
+        super(options);
+
+        this.filterFunc = filterFunc;
+        this.rewriteAction = rewriteAction;
+
+        this.decoder = false;
+        this.encoder = false;
+        this.continue = false;
+    }
+
+    _transform(data, encoding, callback) {
+        this.processIncoming(data, callback);
+    }
+
+    _flush(callback) {
+        if (this.decoder) {
+            // emit an empty node just in case there is pending data to end
+            return this.processIncoming(
+                {
+                    type: 'none'
+                },
+                callback
+            );
+        }
+        return callback();
+    }
+
+    processIncoming(data, callback) {
+        if (this.decoder && data.type === 'body') {
+            // data to parse
+            if (!this.decoder.write(data.value)) {
+                return this.decoder.once('drain', callback);
+            } else {
+                return callback();
+            }
+        } else if (this.decoder && data.type !== 'body') {
+            // stop decoding.
+            // we can not process the current data chunk as we need to wait until
+            // the parsed data is completely processed, so we store a reference to the
+            // continue callback
+            this.continue = () => {
+                this.continue = false;
+                this.decoder = false;
+                this.encoder = false;
+                this.processIncoming(data, callback);
+            };
+            return this.decoder.end();
+        } else if (data.type === 'node' && this.filterFunc(data)) {
+            // found matching node, create new handler
+            this.emit('node', this.createDecodePair(data));
+        } else if (this.readable && data.type !== 'none') {
+            // we don't care about this data, just pass it over to the joiner
+            this.push(data);
+        }
+        callback();
+    }
+
+    createDecodePair(node) {
+        this.decoder = node.getDecoder();
+
+        if (['base64', 'quoted-printable'].includes(node.encoding)) {
+            this.encoder = node.getEncoder();
+        } else {
+            this.encoder = node.getEncoder('quoted-printable');
+        }
+
+        let lastByte = false;
+
+        let decoder = this.decoder;
+        let encoder = this.encoder;
+        let firstChunk = true;
+        decoder.$reading = false;
+
+        let readFromEncoder = () => {
+            decoder.$reading = true;
+
+            let data = encoder.read();
+            if (data === null) {
+                decoder.$reading = false;
+                return;
+            }
+
+            if (firstChunk) {
+                firstChunk = false;
+                if (this.readable) {
+                    this.push(node);
+                    if (node.type === 'body') {
+                        lastByte = node.value && node.value.length && node.value[node.value.length - 1];
+                    }
+                }
+            }
+
+            let writeMore = true;
+            if (this.readable) {
+                writeMore = this.push({
+                    node,
+                    type: 'body',
+                    value: data
+                });
+                lastByte = data && data.length && data[data.length - 1];
+            }
+
+            if (writeMore) {
+                return setImmediate(readFromEncoder);
+            } else {
+                encoder.pause();
+                // no idea how to catch drain? use timeout for now as poor man's substitute
+                // this.once('drain', () => encoder.resume());
+                setTimeout(() => {
+                    encoder.resume();
+                    setImmediate(readFromEncoder);
+                }, 100);
+            }
+        };
+
+        encoder.on('readable', () => {
+            if (!decoder.$reading) {
+                return readFromEncoder();
+            }
+        });
+
+        encoder.on('end', () => {
+            if (firstChunk) {
+                firstChunk = false;
+                if (this.readable) {
+                    this.push(node);
+                    if (node.type === 'body') {
+                        lastByte = node.value && node.value.length && node.value[node.value.length - 1];
+                    }
+                }
+            }
+
+            if (lastByte !== 0x0a) {
+                // make sure there is a terminating line break
+                this.push({
+                    node,
+                    type: 'body',
+                    value: Buffer.from([0x0a])
+                });
+            }
+
+            if (this.continue) {
+                return this.continue();
+            }
+        });
+
+        if (/^text\//.test(node.contentType) && node.flowed) {
+            // text/plain; format=flowed is a special case
+            let flowDecoder = decoder;
+            decoder = new FlowedDecoder({
+                delSp: node.delSp,
+                encoding: node.encoding
+            });
+            flowDecoder.on('error', err => {
+                decoder.emit('error', err);
+            });
+            flowDecoder.pipe(decoder);
+
+            // we don't know what kind of data we are going to get, does it comply with the
+            // requirements of format=flowed, so we just cancel it
+            node.flowed = false;
+            node.delSp = false;
+            node.setContentType();
+        }
+
+        return {
+            node,
+            decoder,
+            encoder
+        };
+    }
+}
+
+module.exports = NodeRewriter;

package/lib/node-streamer.js

@@ -0,0 +1,121 @@
+'use strict';
+
+// Helper class to rewrite nodes with specific mime type
+
+const Transform = require('stream').Transform;
+const FlowedDecoder = require('./flowed-decoder');
+
+/**
+ * NodeRewriter Transform stream. Updates content for all nodes with specified mime type
+ *
+ * @constructor
+ * @param {String} mimeType Define the Mime-Type to look for
+ * @param {Function} streamAction Function to run with the node content
+ */
+class NodeStreamer extends Transform {
+    constructor(filterFunc, streamAction) {
+        let options = {
+            readableObjectMode: true,
+            writableObjectMode: true
+        };
+        super(options);
+
+        this.filterFunc = filterFunc;
+        this.streamAction = streamAction;
+
+        this.decoder = false;
+        this.canContinue = false;
+        this.continue = false;
+    }
+
+    _transform(data, encoding, callback) {
+        this.processIncoming(data, callback);
+    }
+
+    _flush(callback) {
+        if (this.decoder) {
+            // emit an empty node just in case there is pending data to end
+            return this.processIncoming(
+                {
+                    type: 'none'
+                },
+                callback
+            );
+        }
+        return callback();
+    }
+
+    processIncoming(data, callback) {
+        if (this.decoder && data.type === 'body') {
+            // data to parse
+            this.push(data);
+            if (!this.decoder.write(data.value)) {
+                return this.decoder.once('drain', callback);
+            } else {
+                return callback();
+            }
+        } else if (this.decoder && data.type !== 'body') {
+            // stop decoding.
+            // we can not process the current data chunk as we need to wait until
+            // the parsed data is completely processed, so we store a reference to the
+            // continue callback
+
+            let doContinue = () => {
+                this.continue = false;
+                this.decoder = false;
+                this.canContinue = false;
+                this.processIncoming(data, callback);
+            };
+
+            if (this.canContinue) {
+                setImmediate(doContinue);
+            } else {
+                this.continue = () => doContinue();
+            }
+
+            return this.decoder.end();
+        } else if (data.type === 'node' && this.filterFunc(data)) {
+            this.push(data);
+            // found matching node, create new handler
+            this.emit('node', this.createDecoder(data));
+        } else if (this.readable && data.type !== 'none') {
+            // we don't care about this data, just pass it over to the joiner
+            this.push(data);
+        }
+        callback();
+    }
+
+    createDecoder(node) {
+        this.decoder = node.getDecoder();
+
+        let decoder = this.decoder;
+        decoder.$reading = false;
+
+        if (/^text\//.test(node.contentType) && node.flowed) {
+            let flowDecoder = decoder;
+            decoder = new FlowedDecoder({
+                delSp: node.delSp
+            });
+            flowDecoder.on('error', err => {
+                decoder.emit('error', err);
+            });
+            flowDecoder.pipe(decoder);
+        }
+
+        return {
+            node,
+            decoder,
+            done: () => {
+                if (typeof this.continue === 'function') {
+                    // called once input stream is processed
+                    this.continue();
+                } else {
+                    // called before input stream is processed
+                    this.canContinue = true;
+                }
+            }
+        };
+    }
+}
+
+module.exports = NodeStreamer;

package/package.json

@@ -0,0 +1,38 @@
+{
+    "name": "@zone-eu/mailsplit",
+    "version": "5.4.6",
+    "description": "Split email messages into an object stream",
+    "main": "index.js",
+    "directories": {
+        "test": "test"
+    },
+    "scripts": {
+        "test": "grunt",
+        "update": "rm -rf node_modules package-lock.json && ncu -u && npm install"
+    },
+    "author": "Andris Reinman",
+    "license": "(MIT OR EUPL-1.1+)",
+    "dependencies": {
+        "libbase64": "1.3.0",
+        "libmime": "5.3.7",
+        "libqp": "2.1.1"
+    },
+    "devDependencies": {
+        "eslint": "8.29.0",
+        "eslint-config-nodemailer": "1.2.0",
+        "eslint-config-prettier": "9.1.0",
+        "grunt": "1.6.1",
+        "grunt-cli": "1.5.0",
+        "grunt-contrib-nodeunit": "5.0.0",
+        "grunt-eslint": "24.0.1",
+        "random-message": "1.1.0"
+    },
+    "files": [
+        "lib",
+        "index.js"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/zone-eu/mailsplit.git"
+    }
+}