@zone-eu/mailsplit 5.4.6

package/lib/headers.js

@@ -0,0 +1,238 @@
+'use strict';
+
+const libmime = require('libmime');
+
+/**
+ * Class Headers to parse and handle message headers. Headers instance allows to
+ * check existing, delete or add new headers
+ */
+class Headers {
+    constructor(headers, config) {
+        config = config || {};
+
+        if (Array.isArray(headers)) {
+            // already using parsed headers
+            this.changed = true;
+            this.headers = false;
+            this.parsed = true;
+            this.lines = headers;
+        } else {
+            // using original string/buffer headers
+            this.changed = false;
+            this.headers = headers;
+            this.parsed = false;
+            this.lines = false;
+        }
+        this.mbox = false;
+        this.http = false;
+
+        this.libmime = new libmime.Libmime({ Iconv: config.Iconv });
+    }
+
+    hasHeader(key) {
+        if (!this.parsed) {
+            this._parseHeaders();
+        }
+        key = this._normalizeHeader(key);
+        return typeof this.lines.find(line => line.key === key) === 'object';
+    }
+
+    get(key) {
+        if (!this.parsed) {
+            this._parseHeaders();
+        }
+        key = this._normalizeHeader(key);
+        let lines = this.lines.filter(line => line.key === key).map(line => line.line);
+
+        return lines;
+    }
+
+    getDecoded(key) {
+        return this.get(key)
+            .map(line => this.libmime.decodeHeader(line))
+            .filter(line => line && line.value);
+    }
+
+    getFirst(key) {
+        if (!this.parsed) {
+            this._parseHeaders();
+        }
+        key = this._normalizeHeader(key);
+        let header = this.lines.find(line => line.key === key);
+        if (!header) {
+            return '';
+        }
+        return ((this.libmime.decodeHeader(header.line) || {}).value || '').toString().trim();
+    }
+
+    getList() {
+        if (!this.parsed) {
+            this._parseHeaders();
+        }
+        return this.lines;
+    }
+
+    add(key, value, index) {
+        if (typeof value === 'undefined') {
+            return;
+        }
+
+        if (typeof value === 'number') {
+            value = value.toString();
+        }
+
+        if (typeof value === 'string') {
+            value = Buffer.from(value);
+        }
+
+        value = value.toString('binary');
+        this.addFormatted(key, this.libmime.foldLines(key + ': ' + value.replace(/\r?\n/g, ''), 76, false), index);
+    }
+
+    addFormatted(key, line, index) {
+        if (!this.parsed) {
+            this._parseHeaders();
+        }
+        index = index || 0;
+        this.changed = true;
+
+        if (!line) {
+            return;
+        }
+
+        if (typeof line !== 'string') {
+            line = line.toString('binary');
+        }
+
+        let header = {
+            key: this._normalizeHeader(key),
+            line
+        };
+
+        if (index < 1) {
+            this.lines.unshift(header);
+        } else if (index >= this.lines.length) {
+            this.lines.push(header);
+        } else {
+            this.lines.splice(index, 0, header);
+        }
+    }
+
+    remove(key) {
+        if (!this.parsed) {
+            this._parseHeaders();
+        }
+        key = this._normalizeHeader(key);
+        for (let i = this.lines.length - 1; i >= 0; i--) {
+            if (this.lines[i].key === key) {
+                this.changed = true;
+                this.lines.splice(i, 1);
+            }
+        }
+    }
+
+    update(key, value, relativeIndex) {
+        if (!this.parsed) {
+            this._parseHeaders();
+        }
+        let keyName = key;
+        let index = 0;
+        key = this._normalizeHeader(key);
+        let relativeIndexCount = 0;
+        let relativeMatchFound = false;
+        for (let i = this.lines.length - 1; i >= 0; i--) {
+            if (this.lines[i].key === key) {
+                if (relativeIndex && relativeIndex !== relativeIndexCount) {
+                    relativeIndexCount++;
+                    continue;
+                }
+                index = i;
+                this.changed = true;
+                this.lines.splice(i, 1);
+                if (relativeIndex) {
+                    relativeMatchFound = true;
+                    break;
+                }
+            }
+        }
+
+        if (relativeIndex && !relativeMatchFound) {
+            return;
+        }
+
+        this.add(keyName, value, index);
+    }
+
+    build(lineEnd) {
+        if (!this.changed && !lineEnd) {
+            return typeof this.headers === 'string' ? Buffer.from(this.headers, 'binary') : this.headers;
+        }
+
+        if (!this.parsed) {
+            this._parseHeaders();
+        }
+
+        lineEnd = lineEnd || '\r\n';
+
+        let headers = this.lines.map(line => line.line.replace(/\r?\n/g, lineEnd)).join(lineEnd) + `${lineEnd}${lineEnd}`;
+
+        if (this.mbox) {
+            headers = this.mbox + lineEnd + headers;
+        }
+
+        if (this.http) {
+            headers = this.http + lineEnd + headers;
+        }
+
+        return Buffer.from(headers, 'binary');
+    }
+
+    _normalizeHeader(key) {
+        return (key || '').toLowerCase().trim();
+    }
+
+    _parseHeaders() {
+        if (!this.headers) {
+            this.lines = [];
+            this.parsed = true;
+            return;
+        }
+
+        let lines = this.headers
+            .toString('binary')
+            .replace(/[\r\n]+$/, '')
+            .split(/\r?\n/);
+
+        for (let i = lines.length - 1; i >= 0; i--) {
+            let chr = lines[i].charAt(0);
+            if (i && (chr === ' ' || chr === '\t')) {
+                lines[i - 1] += '\r\n' + lines[i];
+                lines.splice(i, 1);
+            } else {
+                let line = lines[i];
+                if (!i && /^From /i.test(line)) {
+                    // mbox file
+                    this.mbox = line;
+                    lines.splice(i, 1);
+                    continue;
+                } else if (!i && /^POST /i.test(line)) {
+                    // HTTP POST request
+                    this.http = line;
+                    lines.splice(i, 1);
+                    continue;
+                }
+                let key = this._normalizeHeader(line.substr(0, line.indexOf(':')));
+                lines[i] = {
+                    key,
+                    line
+                };
+            }
+        }
+
+        this.lines = lines;
+        this.parsed = true;
+    }
+}
+
+// expose to the world
+module.exports = Headers;

package/lib/message-joiner.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const Transform = require('stream').Transform;
+
+class MessageJoiner extends Transform {
+    constructor() {
+        let options = {
+            readableObjectMode: false,
+            writableObjectMode: true
+        };
+        super(options);
+    }
+
+    _transform(obj, encoding, callback) {
+        if (Buffer.isBuffer(obj)) {
+            this.push(obj);
+        } else if (obj.type === 'node') {
+            this.push(obj.getHeaders());
+        } else if (obj.value) {
+            this.push(obj.value);
+        }
+        return callback();
+    }
+
+    _flush(callback) {
+        return callback();
+    }
+}
+
+module.exports = MessageJoiner;

package/lib/message-splitter.js

@@ -0,0 +1,422 @@
+'use strict';
+
+const Transform = require('stream').Transform;
+const MimeNode = require('./mime-node');
+
+const MAX_HEAD_SIZE = 1 * 1024 * 1024;
+const MAX_CHILD_NODES = 1000;
+
+const HEAD = 0x01;
+const BODY = 0x02;
+
+class MessageSplitter extends Transform {
+    constructor(config) {
+        let options = {
+            readableObjectMode: true,
+            writableObjectMode: false
+        };
+        super(options);
+
+        this.config = config || {};
+        this.maxHeadSize = this.config.maxHeadSize || MAX_HEAD_SIZE;
+        this.maxChildNodes = this.config.maxChildNodes || MAX_CHILD_NODES;
+        this.tree = [];
+        this.nodeCounter = 0;
+        this.newNode();
+        this.tree.push(this.node);
+        this.line = false;
+        this.hasFailed = false;
+    }
+
+    _transform(chunk, encoding, callback) {
+        // process line by line
+        // find next line ending
+        let pos = 0;
+        let i = 0;
+        let group = {
+            type: 'none'
+        };
+        let groupstart = this.line ? -this.line.length : 0;
+        let groupend = 0;
+
+        let checkTrailingLinebreak = data => {
+            if (data.type === 'body' && data.node.parentNode && data.value && data.value.length) {
+                if (data.value[data.value.length - 1] === 0x0a) {
+                    groupstart--;
+                    groupend--;
+                    pos--;
+                    if (data.value.length > 1 && data.value[data.value.length - 2] === 0x0d) {
+                        groupstart--;
+                        groupend--;
+                        pos--;
+                        if (groupstart < 0 && !this.line) {
+                            // store only <CR> as <LF> should be on the positive side
+                            this.line = Buffer.allocUnsafe(1);
+                            this.line[0] = 0x0d;
+                        }
+                        data.value = data.value.slice(0, data.value.length - 2);
+                    } else {
+                        data.value = data.value.slice(0, data.value.length - 1);
+                    }
+                } else if (data.value[data.value.length - 1] === 0x0d) {
+                    groupstart--;
+                    groupend--;
+                    pos--;
+                    data.value = data.value.slice(0, data.value.length - 1);
+                }
+            }
+        };
+
+        let iterateData = () => {
+            for (let len = chunk.length; i < len; i++) {
+                // find next <LF>
+                if (chunk[i] === 0x0a) {
+                    // line end
+
+                    let start = Math.max(pos, 0);
+                    pos = ++i;
+
+                    return this.processLine(chunk.slice(start, i), false, (err, data, flush) => {
+                        if (err) {
+                            this.hasFailed = true;
+                            return setImmediate(() => callback(err));
+                        }
+
+                        if (!data) {
+                            return setImmediate(iterateData);
+                        }
+
+                        if (flush) {
+                            if (group && group.type !== 'none') {
+                                if (group.type === 'body' && groupend >= groupstart && group.node.parentNode) {
+                                    // do not include the last line ending for body
+                                    if (chunk[groupend - 1] === 0x0a) {
+                                        groupend--;
+                                        if (groupend >= groupstart && chunk[groupend - 1] === 0x0d) {
+                                            groupend--;
+                                        }
+                                    }
+                                }
+                                if (groupstart !== groupend) {
+                                    group.value = chunk.slice(groupstart, groupend);
+                                    if (groupend < i) {
+                                        data.value = chunk.slice(groupend, i);
+                                    }
+                                }
+                                this.push(group);
+                                group = {
+                                    type: 'none'
+                                };
+                                groupstart = groupend = i;
+                            }
+                            this.push(data);
+                            groupend = i;
+                            return setImmediate(iterateData);
+                        }
+
+                        if (data.type === group.type) {
+                            // shift slice end position forward
+                            groupend = i;
+                        } else {
+                            if (group.type === 'body' && groupend >= groupstart && group.node.parentNode) {
+                                // do not include the last line ending for body
+                                if (chunk[groupend - 1] === 0x0a) {
+                                    groupend--;
+                                    if (groupend >= groupstart && chunk[groupend - 1] === 0x0d) {
+                                        groupend--;
+                                    }
+                                }
+                            }
+
+                            if (group.type !== 'none' && group.type !== 'node') {
+                                // we have a previous data/body chunk to output
+                                if (groupstart !== groupend) {
+                                    group.value = chunk.slice(groupstart, groupend);
+                                    if (group.value && group.value.length) {
+                                        this.push(group);
+                                        group = {
+                                            type: 'none'
+                                        };
+                                    }
+                                }
+                            }
+
+                            if (data.type === 'node') {
+                                this.push(data);
+                                groupstart = i;
+                                groupend = i;
+                            } else if (groupstart < 0) {
+                                groupstart = i;
+                                groupend = i;
+                                checkTrailingLinebreak(data);
+                                if (data.value && data.value.length) {
+                                    this.push(data);
+                                }
+                            } else {
+                                // start new body/data chunk
+                                group = data;
+                                groupstart = groupend;
+                                groupend = i;
+                            }
+                        }
+                        return setImmediate(iterateData);
+                    });
+                }
+            }
+
+            // skip last linebreak for body
+            if (pos >= groupstart + 1 && group.type === 'body' && group.node.parentNode) {
+                // do not include the last line ending for body
+                if (chunk[pos - 1] === 0x0a) {
+                    pos--;
+                    if (pos >= groupstart && chunk[pos - 1] === 0x0d) {
+                        pos--;
+                    }
+                }
+            }
+
+            if (group.type !== 'none' && group.type !== 'node' && pos > groupstart) {
+                // we have a leftover data/body chunk to push out
+                group.value = chunk.slice(groupstart, pos);
+
+                if (group.value && group.value.length) {
+                    this.push(group);
+                    group = {
+                        type: 'none'
+                    };
+                }
+            }
+
+            if (pos < chunk.length) {
+                if (this.line) {
+                    this.line = Buffer.concat([this.line, chunk.slice(pos)]);
+                } else {
+                    this.line = chunk.slice(pos);
+                }
+            }
+            callback();
+        };
+
+        setImmediate(iterateData);
+    }
+
+    _flush(callback) {
+        if (this.hasFailed) {
+            return callback();
+        }
+        this.processLine(false, true, (err, data) => {
+            if (err) {
+                return setImmediate(() => callback(err));
+            }
+            if (data && (data.type === 'node' || (data.value && data.value.length))) {
+                this.push(data);
+            }
+            callback();
+        });
+    }
+
+    compareBoundary(line, startpos, boundary) {
+        // --{boundary}\r\n or --{boundary}--\r\n
+        if (line.length < boundary.length + 3 + startpos || line.length > boundary.length + 6 + startpos) {
+            return false;
+        }
+        for (let i = 0; i < boundary.length; i++) {
+            if (line[i + 2 + startpos] !== boundary[i]) {
+                return false;
+            }
+        }
+
+        let pos = 0;
+        for (let i = boundary.length + 2 + startpos; i < line.length; i++) {
+            let c = line[i];
+            if (pos === 0 && (c === 0x0d || c === 0x0a)) {
+                // 1: next node
+                return 1;
+            }
+            if (pos === 0 && c !== 0x2d) {
+                // expecting "-"
+                return false;
+            }
+            if (pos === 1 && c !== 0x2d) {
+                // expecting "-"
+                return false;
+            }
+            if (pos === 2 && c !== 0x0d && c !== 0x0a) {
+                // expecting line terminator, either <CR> or <LF>
+                return false;
+            }
+            if (pos === 3 && c !== 0x0a) {
+                // expecting line terminator <LF>
+                return false;
+            }
+            pos++;
+        }
+
+        // 2: multipart end
+        return 2;
+    }
+
+    checkBoundary(line) {
+        let startpos = 0;
+        if (line.length >= 1 && (line[0] === 0x0d || line[0] === 0x0a)) {
+            startpos++;
+            if (line.length >= 2 && (line[0] === 0x0d || line[1] === 0x0a)) {
+                startpos++;
+            }
+        }
+        if (line.length < 4 || line[startpos] !== 0x2d || line[startpos + 1] !== 0x2d) {
+            // defnitely not a boundary
+            return false;
+        }
+
+        let boundary;
+        if (this.node._boundary && (boundary = this.compareBoundary(line, startpos, this.node._boundary))) {
+            // 1: next child
+            // 2: multipart end
+            return boundary;
+        }
+
+        if (this.node._parentBoundary && (boundary = this.compareBoundary(line, startpos, this.node._parentBoundary))) {
+            // 3: next sibling
+            // 4: parent end
+            return boundary + 2;
+        }
+
+        return false;
+    }
+
+    processLine(line, final, next) {
+        let flush = false;
+
+        if (this.line && line) {
+            line = Buffer.concat([this.line, line]);
+            this.line = false;
+        } else if (this.line && !line) {
+            line = this.line;
+            this.line = false;
+        }
+
+        if (!line) {
+            line = Buffer.alloc(0);
+        }
+
+        if (this.nodeCounter > this.maxChildNodes) {
+            let err = new Error('Max allowed child nodes exceeded');
+            err.code = 'EMAXLEN';
+            return next(err);
+        }
+
+        // we check boundary outside the HEAD/BODY scope as it may appear anywhere
+        let boundary = this.checkBoundary(line);
+        if (boundary) {
+            // reached boundary, switch context
+            switch (boundary) {
+                case 1:
+                    // next child
+                    this.newNode(this.node);
+                    flush = true;
+                    break;
+                case 2:
+                    // reached end of children, keep current node
+                    break;
+                case 3: {
+                    // next sibling
+                    let parentNode = this.node.parentNode;
+                    if (parentNode && parentNode.contentType === 'message/rfc822') {
+                        // special case where immediate parent is an inline message block
+                        // move up another step
+                        parentNode = parentNode.parentNode;
+                    }
+                    this.newNode(parentNode);
+                    flush = true;
+                    break;
+                }
+                case 4:
+                    // special case when boundary close a node with only header.
+                    if (this.node && this.node._headerlen && !this.node.headers) {
+                        this.node.parseHeaders();
+                        this.push(this.node);
+                    }
+                    // move up
+                    if (this.tree.length) {
+                        this.node = this.tree.pop();
+                    }
+                    this.state = BODY;
+                    break;
+            }
+
+            return next(
+                null,
+                {
+                    node: this.node,
+                    type: 'data',
+                    value: line
+                },
+                flush
+            );
+        }
+
+        switch (this.state) {
+            case HEAD: {
+                this.node.addHeaderChunk(line);
+                if (this.node._headerlen > this.maxHeadSize) {
+                    let err = new Error('Max header size for a MIME node exceeded');
+                    err.code = 'EMAXLEN';
+                    return next(err);
+                }
+                if (final || (line.length === 1 && line[0] === 0x0a) || (line.length === 2 && line[0] === 0x0d && line[1] === 0x0a)) {
+                    let currentNode = this.node;
+
+                    currentNode.parseHeaders();
+
+                    // if the content is attached message then just continue
+                    if (
+                        currentNode.contentType === 'message/rfc822' &&
+                        !this.config.ignoreEmbedded &&
+                        (!currentNode.encoding || ['7bit', '8bit', 'binary'].includes(currentNode.encoding)) &&
+                        (this.config.defaultInlineEmbedded ? currentNode.disposition !== 'attachment' : currentNode.disposition === 'inline')
+                    ) {
+                        currentNode.messageNode = true;
+                        this.newNode(currentNode);
+                        if (currentNode.parentNode) {
+                            this.node._parentBoundary = currentNode.parentNode._boundary;
+                        }
+                    } else {
+                        if (currentNode.contentType === 'message/rfc822') {
+                            currentNode.messageNode = false;
+                        }
+                        this.state = BODY;
+                        if (currentNode.multipart && currentNode._boundary) {
+                            this.tree.push(currentNode);
+                        }
+                    }
+
+                    return next(null, currentNode, flush);
+                }
+
+                return next();
+            }
+            case BODY: {
+                return next(
+                    null,
+                    {
+                        node: this.node,
+                        type: this.node.multipart ? 'data' : 'body',
+                        value: line
+                    },
+                    flush
+                );
+            }
+        }
+
+        next(null, false);
+    }
+
+    newNode(parent) {
+        this.node = new MimeNode(parent || false, this.config);
+        this.state = HEAD;
+        this.nodeCounter++;
+    }
+}
+
+module.exports = MessageSplitter;