You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1017 lines
29 KiB
JavaScript
1017 lines
29 KiB
JavaScript
var EventEmitter = require('events').EventEmitter,
|
|
ReadableStream = require('stream').Readable
|
|
|| require('readable-stream').Readable,
|
|
inherits = require('util').inherits,
|
|
inspect = require('util').inspect;
|
|
|
|
var utf7 = require('utf7').imap,
|
|
jsencoding; // lazy-loaded
|
|
|
|
var CH_LF = 10,
|
|
LITPLACEHOLDER = String.fromCharCode(0),
|
|
EMPTY_READCB = function(n) {},
|
|
RE_INTEGER = /^\d+$/,
|
|
RE_PRECEDING = /^(?:(?:\*|A\d+) )|\+ ?/,
|
|
RE_BODYLITERAL = /BODY\[(.*)\] \{(\d+)\}$/i,
|
|
RE_BODYINLINEKEY = /^BODY\[(.*)\]$/i,
|
|
RE_SEQNO = /^\* (\d+)/,
|
|
RE_LISTCONTENT = /^\((.*)\)$/,
|
|
RE_LITERAL = /\{(\d+)\}$/,
|
|
RE_UNTAGGED = /^\* (?:(OK|NO|BAD|BYE|FLAGS|ID|LIST|LSUB|SEARCH|STATUS|CAPABILITY|NAMESPACE|PREAUTH|SORT|THREAD|ESEARCH|QUOTA|QUOTAROOT)|(\d+) (EXPUNGE|FETCH|RECENT|EXISTS))(?:(?: \[([^\]]+)\])?(?: (.+))?)?$/i,
|
|
RE_TAGGED = /^A(\d+) (OK|NO|BAD) (?:\[([^\]]+)\] )?(.+)$/i,
|
|
RE_CONTINUE = /^\+(?: (?:\[([^\]]+)\] )?(.+))?$/i,
|
|
RE_CRLF = /\r\n/g,
|
|
RE_HDR = /^([^:]+):[ \t]?(.+)?$/,
|
|
RE_ENCWORD = /=\?([^?*]*?)(?:\*.*?)?\?([qb])\?(.*?)\?=/gi,
|
|
RE_ENCWORD_END = /=\?([^?*]*?)(?:\*.*?)?\?([qb])\?(.*?)\?=$/i,
|
|
RE_ENCWORD_BEGIN = /^[ \t]=\?([^?*]*?)(?:\*.*?)?\?([qb])\?(.*?)\?=/i,
|
|
RE_QENC = /(?:=([a-fA-F0-9]{2}))|_/g,
|
|
RE_SEARCH_MODSEQ = /^(.+) \(MODSEQ (.+?)\)$/i,
|
|
RE_LWS_ONLY = /^[ \t]*$/;
|
|
|
|
function Parser(stream, debug) {
|
|
if (!(this instanceof Parser))
|
|
return new Parser(stream, debug);
|
|
|
|
EventEmitter.call(this);
|
|
|
|
this._stream = undefined;
|
|
this._body = undefined;
|
|
this._literallen = 0;
|
|
this._literals = [];
|
|
this._buffer = '';
|
|
this._ignoreReadable = false;
|
|
this.debug = debug;
|
|
|
|
var self = this;
|
|
this._cbReadable = function() {
|
|
if (self._ignoreReadable)
|
|
return;
|
|
if (self._literallen > 0 && !self._body)
|
|
self._tryread(self._literallen);
|
|
else
|
|
self._tryread();
|
|
};
|
|
|
|
this.setStream(stream);
|
|
|
|
process.nextTick(this._cbReadable);
|
|
}
|
|
inherits(Parser, EventEmitter);
|
|
|
|
Parser.prototype.setStream = function(stream) {
|
|
if (this._stream)
|
|
this._stream.removeListener('readable', this._cbReadable);
|
|
|
|
if (/^v0\.8\./.test(process.version)) {
|
|
this._stream = (new ReadableStream()).wrap(stream);
|
|
|
|
// since Readable.wrap() proxies events, we need to remove at least the
|
|
// proxied 'error' event since this can cause problems and Parser doesn't
|
|
// care about such events
|
|
stream._events.error.pop();
|
|
} else
|
|
this._stream = stream;
|
|
|
|
this._stream.on('readable', this._cbReadable);
|
|
};
|
|
|
|
Parser.prototype._tryread = function(n) {
|
|
if (this._stream.readable) {
|
|
var r = this._stream.read(n);
|
|
r && this._parse(r);
|
|
}
|
|
};
|
|
|
|
Parser.prototype._parse = function(data) {
|
|
var i = 0, datalen = data.length, idxlf;
|
|
|
|
if (this._literallen > 0) {
|
|
if (this._body) {
|
|
var body = this._body;
|
|
if (datalen > this._literallen) {
|
|
var litlen = this._literallen;
|
|
i = litlen;
|
|
this._literallen = 0;
|
|
body.push(data.slice(0, litlen));
|
|
} else {
|
|
this._literallen -= datalen;
|
|
var r = body.push(data);
|
|
if (!r && this._literallen > 0) {
|
|
body._read = this._cbReadable;
|
|
return;
|
|
}
|
|
i = datalen;
|
|
}
|
|
if (this._literallen === 0) {
|
|
this._body = undefined;
|
|
body._read = EMPTY_READCB;
|
|
body.push(null);
|
|
}
|
|
} else {
|
|
if (datalen > this._literallen)
|
|
this._literals.push(data.slice(0, this._literallen));
|
|
else
|
|
this._literals.push(data);
|
|
i = this._literallen;
|
|
this._literallen = 0;
|
|
}
|
|
}
|
|
|
|
while (i < datalen) {
|
|
idxlf = indexOfCh(data, datalen, i, CH_LF);
|
|
if (idxlf === -1) {
|
|
this._buffer += data.toString('utf8', i);
|
|
break;
|
|
} else {
|
|
this._buffer += data.toString('utf8', i, idxlf);
|
|
this._buffer = this._buffer.trim();
|
|
i = idxlf + 1;
|
|
|
|
this.debug && this.debug('<= ' + inspect(this._buffer));
|
|
|
|
if (RE_PRECEDING.test(this._buffer)) {
|
|
var firstChar = this._buffer[0];
|
|
if (firstChar === '*')
|
|
this._resUntagged();
|
|
else if (firstChar === 'A')
|
|
this._resTagged();
|
|
else if (firstChar === '+')
|
|
this._resContinue();
|
|
|
|
if (this._literallen > 0 && i < datalen) {
|
|
this._ignoreReadable = true;
|
|
// literal data included in this chunk -- put it back onto stream
|
|
this._stream.unshift(data.slice(i));
|
|
this._ignoreReadable = false;
|
|
i = datalen;
|
|
if (!this._body) {
|
|
// check if unshifted contents satisfies non-body literal length
|
|
this._tryread(this._literallen);
|
|
}
|
|
}
|
|
} else {
|
|
this.emit('other', this._buffer);
|
|
this._buffer = '';
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this._literallen === 0 || this._body)
|
|
this._tryread();
|
|
};
|
|
|
|
Parser.prototype._resTagged = function() {
|
|
var m;
|
|
if (m = RE_LITERAL.exec(this._buffer)) {
|
|
// non-BODY literal -- buffer it
|
|
this._buffer = this._buffer.replace(RE_LITERAL, LITPLACEHOLDER);
|
|
this._literallen = parseInt(m[1], 10);
|
|
} else if (m = RE_TAGGED.exec(this._buffer)) {
|
|
this._buffer = '';
|
|
this._literals = [];
|
|
|
|
this.emit('tagged', {
|
|
type: m[2].toLowerCase(),
|
|
tagnum: parseInt(m[1], 10),
|
|
textCode: (m[3] ? parseTextCode(m[3], this._literals) : m[3]),
|
|
text: m[4]
|
|
});
|
|
} else
|
|
this._buffer = '';
|
|
};
|
|
|
|
Parser.prototype._resUntagged = function() {
|
|
var m;
|
|
if (m = RE_BODYLITERAL.exec(this._buffer)) {
|
|
// BODY literal -- stream it
|
|
var which = m[1], size = parseInt(m[2], 10);
|
|
this._literallen = size;
|
|
this._body = new ReadableStream();
|
|
this._body._readableState.sync = false;
|
|
this._body._read = EMPTY_READCB;
|
|
m = RE_SEQNO.exec(this._buffer);
|
|
this._buffer = this._buffer.replace(RE_BODYLITERAL, '');
|
|
this.emit('body', this._body, {
|
|
seqno: parseInt(m[1], 10),
|
|
which: which,
|
|
size: size
|
|
});
|
|
} else if (m = RE_LITERAL.exec(this._buffer)) {
|
|
// non-BODY literal -- buffer it
|
|
this._buffer = this._buffer.replace(RE_LITERAL, LITPLACEHOLDER);
|
|
this._literallen = parseInt(m[1], 10);
|
|
} else if (m = RE_UNTAGGED.exec(this._buffer)) {
|
|
this._buffer = '';
|
|
// normal single line response
|
|
|
|
// m[1] or m[3] = response type
|
|
// if m[3] is set, m[2] = sequence number (for FETCH) or count
|
|
// m[4] = response text code (optional)
|
|
// m[5] = response text (optional)
|
|
|
|
var type, num, textCode, val;
|
|
if (m[2] !== undefined)
|
|
num = parseInt(m[2], 10);
|
|
if (m[4] !== undefined)
|
|
textCode = parseTextCode(m[4], this._literals);
|
|
|
|
type = (m[1] || m[3]).toLowerCase();
|
|
|
|
if (type === 'flags'
|
|
|| type === 'search'
|
|
|| type === 'capability'
|
|
|| type === 'sort') {
|
|
if (m[5]) {
|
|
if (type === 'search' && RE_SEARCH_MODSEQ.test(m[5])) {
|
|
// CONDSTORE search response
|
|
var p = RE_SEARCH_MODSEQ.exec(m[5]);
|
|
val = {
|
|
results: p[1].split(' '),
|
|
modseq: p[2]
|
|
};
|
|
} else {
|
|
if (m[5][0] === '(')
|
|
val = RE_LISTCONTENT.exec(m[5])[1].split(' ');
|
|
else
|
|
val = m[5].split(' ');
|
|
|
|
if (type === 'search' || type === 'sort')
|
|
val = val.map(function(v) { return parseInt(v, 10); });
|
|
}
|
|
} else
|
|
val = [];
|
|
} else if (type === 'thread') {
|
|
if (m[5])
|
|
val = parseExpr(m[5], this._literals);
|
|
else
|
|
val = [];
|
|
} else if (type === 'list' || type === 'lsub')
|
|
val = parseBoxList(m[5], this._literals);
|
|
else if (type === 'id')
|
|
val = parseId(m[5], this._literals);
|
|
else if (type === 'status')
|
|
val = parseStatus(m[5], this._literals);
|
|
else if (type === 'fetch')
|
|
val = parseFetch.call(this, m[5], this._literals, num);
|
|
else if (type === 'namespace')
|
|
val = parseNamespaces(m[5], this._literals);
|
|
else if (type === 'esearch')
|
|
val = parseESearch(m[5], this._literals);
|
|
else if (type === 'quota')
|
|
val = parseQuota(m[5], this._literals);
|
|
else if (type === 'quotaroot')
|
|
val = parseQuotaRoot(m[5], this._literals);
|
|
else
|
|
val = m[5];
|
|
|
|
this._literals = [];
|
|
|
|
this.emit('untagged', {
|
|
type: type,
|
|
num: num,
|
|
textCode: textCode,
|
|
text: val
|
|
});
|
|
} else
|
|
this._buffer = '';
|
|
};
|
|
|
|
Parser.prototype._resContinue = function() {
|
|
var m = RE_CONTINUE.exec(this._buffer),
|
|
textCode,
|
|
text;
|
|
|
|
this._buffer = '';
|
|
|
|
if (!m)
|
|
return;
|
|
|
|
text = m[2];
|
|
|
|
if (m[1] !== undefined)
|
|
textCode = parseTextCode(m[1], this._literals);
|
|
|
|
this.emit('continue', {
|
|
textCode: textCode,
|
|
text: text
|
|
});
|
|
};
|
|
|
|
function indexOfCh(buffer, len, i, ch) {
|
|
var r = -1;
|
|
for (; i < len; ++i) {
|
|
if (buffer[i] === ch) {
|
|
r = i;
|
|
break;
|
|
}
|
|
}
|
|
return r;
|
|
}
|
|
|
|
function parseTextCode(text, literals) {
|
|
var r = parseExpr(text, literals);
|
|
if (r.length === 1)
|
|
return r[0];
|
|
else
|
|
return { key: r[0], val: r.length === 2 ? r[1] : r.slice(1) };
|
|
}
|
|
|
|
function parseESearch(text, literals) {
|
|
var r = parseExpr(text.toUpperCase().replace('UID', ''), literals),
|
|
attrs = {};
|
|
|
|
// RFC4731 unfortunately is lacking on documentation, so we're going to
|
|
// assume that the response text always begins with (TAG "A123") and skip that
|
|
// part ...
|
|
|
|
for (var i = 1, len = r.length, key, val; i < len; i += 2) {
|
|
key = r[i].toLowerCase();
|
|
val = r[i + 1];
|
|
if (key === 'all')
|
|
val = val.toString().split(',');
|
|
attrs[key] = val;
|
|
}
|
|
|
|
return attrs;
|
|
}
|
|
|
|
function parseId(text, literals) {
|
|
var r = parseExpr(text, literals),
|
|
id = {};
|
|
if (r[0] === null)
|
|
return null;
|
|
for (var i = 0, len = r[0].length; i < len; i += 2)
|
|
id[r[0][i].toLowerCase()] = r[0][i + 1];
|
|
|
|
return id;
|
|
}
|
|
|
|
function parseQuota(text, literals) {
|
|
var r = parseExpr(text, literals),
|
|
resources = {};
|
|
|
|
for (var i = 0, len = r[1].length; i < len; i += 3) {
|
|
resources[r[1][i].toLowerCase()] = {
|
|
usage: r[1][i + 1],
|
|
limit: r[1][i + 2]
|
|
};
|
|
}
|
|
|
|
return {
|
|
root: r[0],
|
|
resources: resources
|
|
};
|
|
}
|
|
|
|
function parseQuotaRoot(text, literals) {
|
|
var r = parseExpr(text, literals);
|
|
|
|
return {
|
|
roots: r.slice(1),
|
|
mailbox: r[0]
|
|
};
|
|
}
|
|
|
|
function parseBoxList(text, literals) {
|
|
var r = parseExpr(text, literals);
|
|
return {
|
|
flags: r[0],
|
|
delimiter: r[1],
|
|
name: utf7.decode(''+r[2])
|
|
};
|
|
}
|
|
|
|
function parseNamespaces(text, literals) {
|
|
var r = parseExpr(text, literals), i, len, j, len2, ns, nsobj, namespaces, n;
|
|
|
|
for (n = 0; n < 3; ++n) {
|
|
if (r[n]) {
|
|
namespaces = [];
|
|
for (i = 0, len = r[n].length; i < len; ++i) {
|
|
ns = r[n][i];
|
|
nsobj = {
|
|
prefix: ns[0],
|
|
delimiter: ns[1],
|
|
extensions: undefined
|
|
};
|
|
if (ns.length > 2)
|
|
nsobj.extensions = {};
|
|
for (j = 2, len2 = ns.length; j < len2; j += 2)
|
|
nsobj.extensions[ns[j]] = ns[j + 1];
|
|
namespaces.push(nsobj);
|
|
}
|
|
r[n] = namespaces;
|
|
}
|
|
}
|
|
|
|
return {
|
|
personal: r[0],
|
|
other: r[1],
|
|
shared: r[2]
|
|
};
|
|
}
|
|
|
|
function parseStatus(text, literals) {
|
|
var r = parseExpr(text, literals), attrs = {};
|
|
// r[1] is [KEY1, VAL1, KEY2, VAL2, .... KEYn, VALn]
|
|
for (var i = 0, len = r[1].length; i < len; i += 2)
|
|
attrs[r[1][i].toLowerCase()] = r[1][i + 1];
|
|
return {
|
|
name: utf7.decode(''+r[0]),
|
|
attrs: attrs
|
|
};
|
|
}
|
|
|
|
function parseFetch(text, literals, seqno) {
|
|
var list = parseExpr(text, literals)[0], attrs = {}, m, body;
|
|
// list is [KEY1, VAL1, KEY2, VAL2, .... KEYn, VALn]
|
|
for (var i = 0, len = list.length, key, val; i < len; i += 2) {
|
|
key = list[i].toLowerCase();
|
|
val = list[i + 1];
|
|
if (key === 'envelope')
|
|
val = parseFetchEnvelope(val);
|
|
else if (key === 'internaldate')
|
|
val = new Date(val);
|
|
else if (key === 'modseq') // always a list of one value
|
|
val = ''+val[0];
|
|
else if (key === 'body' || key === 'bodystructure')
|
|
val = parseBodyStructure(val);
|
|
else if (m = RE_BODYINLINEKEY.exec(list[i])) {
|
|
// a body was sent as a non-literal
|
|
val = new Buffer(''+val);
|
|
body = new ReadableStream();
|
|
body._readableState.sync = false;
|
|
body._read = EMPTY_READCB;
|
|
this.emit('body', body, {
|
|
seqno: seqno,
|
|
which: m[1],
|
|
size: val.length
|
|
});
|
|
body.push(val);
|
|
body.push(null);
|
|
continue;
|
|
}
|
|
attrs[key] = val;
|
|
}
|
|
return attrs;
|
|
}
|
|
|
|
function parseBodyStructure(cur, literals, prefix, partID) {
|
|
var ret = [], i, len;
|
|
if (prefix === undefined) {
|
|
var result = (Array.isArray(cur) ? cur : parseExpr(cur, literals));
|
|
if (result.length)
|
|
ret = parseBodyStructure(result, literals, '', 1);
|
|
} else {
|
|
var part, partLen = cur.length, next;
|
|
if (Array.isArray(cur[0])) { // multipart
|
|
next = -1;
|
|
while (Array.isArray(cur[++next])) {
|
|
ret.push(parseBodyStructure(cur[next],
|
|
literals,
|
|
prefix + (prefix !== '' ? '.' : '')
|
|
+ (partID++).toString(), 1));
|
|
}
|
|
part = { type: cur[next++].toLowerCase() };
|
|
if (partLen > next) {
|
|
if (Array.isArray(cur[next])) {
|
|
part.params = {};
|
|
for (i = 0, len = cur[next].length; i < len; i += 2)
|
|
part.params[cur[next][i].toLowerCase()] = cur[next][i + 1];
|
|
} else
|
|
part.params = cur[next];
|
|
++next;
|
|
}
|
|
} else { // single part
|
|
next = 7;
|
|
if (typeof cur[1] === 'string') {
|
|
part = {
|
|
// the path identifier for this part, useful for fetching specific
|
|
// parts of a message
|
|
partID: (prefix !== '' ? prefix : '1'),
|
|
|
|
// required fields as per RFC 3501 -- null or otherwise
|
|
type: cur[0].toLowerCase(), subtype: cur[1].toLowerCase(),
|
|
params: null, id: cur[3], description: cur[4], encoding: cur[5],
|
|
size: cur[6]
|
|
};
|
|
} else {
|
|
// type information for malformed multipart body
|
|
part = { type: cur[0].toLowerCase(), params: null };
|
|
cur.splice(1, 0, null);
|
|
++partLen;
|
|
next = 2;
|
|
}
|
|
if (Array.isArray(cur[2])) {
|
|
part.params = {};
|
|
for (i = 0, len = cur[2].length; i < len; i += 2)
|
|
part.params[cur[2][i].toLowerCase()] = cur[2][i + 1];
|
|
if (cur[1] === null)
|
|
++next;
|
|
}
|
|
if (part.type === 'message' && part.subtype === 'rfc822') {
|
|
// envelope
|
|
if (partLen > next && Array.isArray(cur[next]))
|
|
part.envelope = parseFetchEnvelope(cur[next]);
|
|
else
|
|
part.envelope = null;
|
|
++next;
|
|
|
|
// body
|
|
if (partLen > next && Array.isArray(cur[next]))
|
|
part.body = parseBodyStructure(cur[next], literals, prefix, 1);
|
|
else
|
|
part.body = null;
|
|
++next;
|
|
}
|
|
if ((part.type === 'text'
|
|
|| (part.type === 'message' && part.subtype === 'rfc822'))
|
|
&& partLen > next)
|
|
part.lines = cur[next++];
|
|
if (typeof cur[1] === 'string' && partLen > next)
|
|
part.md5 = cur[next++];
|
|
}
|
|
// add any extra fields that may or may not be omitted entirely
|
|
parseStructExtra(part, partLen, cur, next);
|
|
ret.unshift(part);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
function parseStructExtra(part, partLen, cur, next) {
|
|
if (partLen > next) {
|
|
// disposition
|
|
// null or a special k/v list with these kinds of values:
|
|
// e.g.: ['Foo', null]
|
|
// ['Foo', ['Bar', 'Baz']]
|
|
// ['Foo', ['Bar', 'Baz', 'Bam', 'Pow']]
|
|
var disposition = { type: null, params: null };
|
|
if (Array.isArray(cur[next])) {
|
|
disposition.type = cur[next][0];
|
|
if (Array.isArray(cur[next][1])) {
|
|
disposition.params = {};
|
|
for (var i = 0, len = cur[next][1].length, key; i < len; i += 2) {
|
|
key = cur[next][1][i].toLowerCase();
|
|
disposition.params[key] = cur[next][1][i + 1];
|
|
}
|
|
}
|
|
} else if (cur[next] !== null)
|
|
disposition.type = cur[next];
|
|
|
|
if (disposition.type === null)
|
|
part.disposition = null;
|
|
else
|
|
part.disposition = disposition;
|
|
|
|
++next;
|
|
}
|
|
if (partLen > next) {
|
|
// language can be a string or a list of one or more strings, so let's
|
|
// make this more consistent ...
|
|
if (cur[next] !== null)
|
|
part.language = (Array.isArray(cur[next]) ? cur[next] : [cur[next]]);
|
|
else
|
|
part.language = null;
|
|
++next;
|
|
}
|
|
if (partLen > next)
|
|
part.location = cur[next++];
|
|
if (partLen > next) {
|
|
// extension stuff introduced by later RFCs
|
|
// this can really be any value: a string, number, or (un)nested list
|
|
// let's not parse it for now ...
|
|
part.extensions = cur[next];
|
|
}
|
|
}
|
|
|
|
function parseFetchEnvelope(list) {
|
|
return {
|
|
date: new Date(list[0]),
|
|
subject: decodeWords(list[1], {
|
|
buffer: undefined,
|
|
encoding: undefined,
|
|
consecutive: false,
|
|
replaces: undefined,
|
|
curReplace: undefined
|
|
}),
|
|
from: parseEnvelopeAddresses(list[2]),
|
|
sender: parseEnvelopeAddresses(list[3]),
|
|
replyTo: parseEnvelopeAddresses(list[4]),
|
|
to: parseEnvelopeAddresses(list[5]),
|
|
cc: parseEnvelopeAddresses(list[6]),
|
|
bcc: parseEnvelopeAddresses(list[7]),
|
|
inReplyTo: list[8],
|
|
messageId: list[9]
|
|
};
|
|
}
|
|
|
|
function parseEnvelopeAddresses(list) {
|
|
var addresses = null;
|
|
if (Array.isArray(list)) {
|
|
addresses = [];
|
|
var inGroup = false, curGroup;
|
|
for (var i = 0, len = list.length, addr; i < len; ++i) {
|
|
addr = list[i];
|
|
if (addr[2] === null) { // end of group addresses
|
|
inGroup = false;
|
|
if (curGroup) {
|
|
addresses.push(curGroup);
|
|
curGroup = undefined;
|
|
}
|
|
} else if (addr[3] === null) { // start of group addresses
|
|
inGroup = true;
|
|
curGroup = {
|
|
group: addr[2],
|
|
addresses: []
|
|
};
|
|
} else { // regular user address
|
|
var info = {
|
|
name: addr[0],
|
|
mailbox: addr[2],
|
|
host: addr[3]
|
|
};
|
|
if (inGroup)
|
|
curGroup.addresses.push(info);
|
|
else if (!inGroup)
|
|
addresses.push(info);
|
|
}
|
|
list[i] = addr;
|
|
}
|
|
if (inGroup) {
|
|
// no end of group found, assume implicit end
|
|
addresses.push(curGroup);
|
|
}
|
|
}
|
|
return addresses;
|
|
}
|
|
|
|
function parseExpr(o, literals, result, start, useBrackets) {
|
|
start = start || 0;
|
|
var inQuote = false,
|
|
lastPos = start - 1,
|
|
isTop = false,
|
|
isBody = false,
|
|
escaping = false,
|
|
val;
|
|
|
|
if (useBrackets === undefined)
|
|
useBrackets = true;
|
|
if (!result)
|
|
result = [];
|
|
if (typeof o === 'string') {
|
|
o = { str: o };
|
|
isTop = true;
|
|
}
|
|
for (var i = start, len = o.str.length; i < len; ++i) {
|
|
if (!inQuote) {
|
|
if (isBody) {
|
|
if (o.str[i] === ']') {
|
|
val = convStr(o.str.substring(lastPos + 1, i + 1), literals);
|
|
result.push(val);
|
|
lastPos = i;
|
|
isBody = false;
|
|
}
|
|
} else if (o.str[i] === '"')
|
|
inQuote = true;
|
|
else if (o.str[i] === ' '
|
|
|| o.str[i] === ')'
|
|
|| (useBrackets && o.str[i] === ']')) {
|
|
if (i - (lastPos + 1) > 0) {
|
|
val = convStr(o.str.substring(lastPos + 1, i), literals);
|
|
result.push(val);
|
|
}
|
|
if ((o.str[i] === ')' || (useBrackets && o.str[i] === ']')) && !isTop)
|
|
return i;
|
|
lastPos = i;
|
|
} else if ((o.str[i] === '(' || (useBrackets && o.str[i] === '['))) {
|
|
if (o.str[i] === '['
|
|
&& i - 4 >= start
|
|
&& o.str.substring(i - 4, i).toUpperCase() === 'BODY') {
|
|
isBody = true;
|
|
lastPos = i - 5;
|
|
} else {
|
|
var innerResult = [];
|
|
i = parseExpr(o, literals, innerResult, i + 1, useBrackets);
|
|
lastPos = i;
|
|
result.push(innerResult);
|
|
}
|
|
}
|
|
} else if (o.str[i] === '\\')
|
|
escaping = !escaping;
|
|
else if (o.str[i] === '"') {
|
|
if (!escaping)
|
|
inQuote = false;
|
|
escaping = false;
|
|
}
|
|
if (i + 1 === len && len - (lastPos + 1) > 0)
|
|
result.push(convStr(o.str.substring(lastPos + 1), literals));
|
|
}
|
|
return (isTop ? result : start);
|
|
}
|
|
|
|
function convStr(str, literals) {
|
|
if (str[0] === '"') {
|
|
str = str.substring(1, str.length - 1);
|
|
var newstr = '', isEscaping = false, p = 0;
|
|
for (var i = 0, len = str.length; i < len; ++i) {
|
|
if (str[i] === '\\') {
|
|
if (!isEscaping)
|
|
isEscaping = true;
|
|
else {
|
|
isEscaping = false;
|
|
newstr += str.substring(p, i - 1);
|
|
p = i;
|
|
}
|
|
} else if (str[i] === '"') {
|
|
if (isEscaping) {
|
|
isEscaping = false;
|
|
newstr += str.substring(p, i - 1);
|
|
p = i;
|
|
}
|
|
}
|
|
}
|
|
if (p === 0)
|
|
return str;
|
|
else {
|
|
newstr += str.substring(p);
|
|
return newstr;
|
|
}
|
|
} else if (str === 'NIL')
|
|
return null;
|
|
else if (RE_INTEGER.test(str)) {
|
|
// some IMAP extensions utilize large (64-bit) integers, which JavaScript
|
|
// can't handle natively, so we'll just keep it as a string if it's too big
|
|
var val = parseInt(str, 10);
|
|
return (val.toString() === str ? val : str);
|
|
} else if (literals && literals.length && str === LITPLACEHOLDER) {
|
|
var l = literals.shift();
|
|
if (Buffer.isBuffer(l))
|
|
l = l.toString('utf8');
|
|
return l;
|
|
}
|
|
|
|
return str;
|
|
}
|
|
|
|
function repeat(chr, len) {
|
|
var s = '';
|
|
for (var i = 0; i < len; ++i)
|
|
s += chr;
|
|
return s;
|
|
}
|
|
|
|
function decodeBytes(buf, encoding, offset, mlen, pendoffset, state, nextBuf) {
|
|
if (!jsencoding)
|
|
jsencoding = require('../deps/encoding/encoding');
|
|
if (jsencoding.encodingExists(encoding)) {
|
|
if (state.buffer !== undefined) {
|
|
if (state.encoding === encoding && state.consecutive) {
|
|
// concatenate buffer + current bytes in hopes of finally having
|
|
// something that's decodable
|
|
var newbuf = new Buffer(state.buffer.length + buf.length);
|
|
state.buffer.copy(newbuf, 0);
|
|
buf.copy(newbuf, state.buffer.length);
|
|
buf = newbuf;
|
|
} else {
|
|
// either:
|
|
// - the current encoded word is not separated by the previous partial
|
|
// encoded word by linear whitespace, OR
|
|
// - the current encoded word and the previous partial encoded word
|
|
// use different encodings
|
|
state.buffer = state.encoding = undefined;
|
|
state.curReplace = undefined;
|
|
}
|
|
}
|
|
var ret, isPartial = false;
|
|
if (state.remainder !== undefined) {
|
|
// use cached remainder from the previous lookahead
|
|
ret = state.remainder;
|
|
state.remainder = undefined;
|
|
} else {
|
|
try {
|
|
ret = jsencoding.TextDecoder(encoding).decode(buf);
|
|
} catch (e) {
|
|
if (e.message.indexOf('Seeking') === 0)
|
|
isPartial = true;
|
|
}
|
|
}
|
|
if (!isPartial && nextBuf) {
|
|
// try to decode a lookahead buffer (current buffer + next buffer)
|
|
// and see if it starts with the decoded value of the current buffer.
|
|
// if not, the current buffer is partial
|
|
var lookahead, lookaheadBuf = new Buffer(buf.length + nextBuf.length);
|
|
buf.copy(lookaheadBuf);
|
|
nextBuf.copy(lookaheadBuf, buf.length);
|
|
try {
|
|
lookahead = jsencoding.TextDecoder(encoding).decode(lookaheadBuf);
|
|
} catch(e) {
|
|
// cannot decode the lookahead, do nothing
|
|
}
|
|
if (lookahead !== undefined) {
|
|
if (lookahead.indexOf(ret) === 0) {
|
|
// the current buffer is whole, cache the lookahead's remainder
|
|
state.remainder = lookahead.substring(ret.length);
|
|
} else {
|
|
isPartial = true;
|
|
ret = undefined;
|
|
}
|
|
}
|
|
}
|
|
if (ret !== undefined) {
|
|
if (state.curReplace) {
|
|
// we have some previous partials which were finally "satisfied" by the
|
|
// current encoded word, so replace from the beginning of the first
|
|
// partial to the end of the current encoded word
|
|
state.replaces.push({
|
|
fromOffset: state.curReplace[0].fromOffset,
|
|
toOffset: offset + mlen,
|
|
val: ret
|
|
});
|
|
state.replaces.splice(state.replaces.indexOf(state.curReplace), 1);
|
|
state.curReplace = undefined;
|
|
} else {
|
|
// normal case where there are no previous partials and we successfully
|
|
// decoded a single encoded word
|
|
state.replaces.push({
|
|
// we ignore linear whitespace between consecutive encoded words
|
|
fromOffset: state.consecutive ? pendoffset : offset,
|
|
toOffset: offset + mlen,
|
|
val: ret
|
|
});
|
|
}
|
|
state.buffer = state.encoding = undefined;
|
|
return;
|
|
} else if (isPartial) {
|
|
// RFC2047 says that each decoded encoded word "MUST represent an integral
|
|
// number of characters. A multi-octet character may not be split across
|
|
// adjacent encoded-words." However, some MUAs appear to go against this,
|
|
// so we join broken encoded words separated by linear white space until
|
|
// we can successfully decode or we see a change in encoding
|
|
state.encoding = encoding;
|
|
state.buffer = buf;
|
|
if (!state.curReplace)
|
|
state.replaces.push(state.curReplace = []);
|
|
state.curReplace.push({
|
|
fromOffset: offset,
|
|
toOffset: offset + mlen,
|
|
// the value we replace this encoded word with if it doesn't end up
|
|
// becoming part of a successful decode
|
|
val: repeat('\uFFFD', buf.length)
|
|
});
|
|
return;
|
|
}
|
|
}
|
|
// in case of unexpected error or unsupported encoding, just substitute the
|
|
// raw bytes
|
|
state.replaces.push({
|
|
fromOffset: offset,
|
|
toOffset: offset + mlen,
|
|
val: buf.toString('binary')
|
|
});
|
|
}
|
|
|
|
function qEncReplacer(match, byte) {
|
|
if (match === '_')
|
|
return ' ';
|
|
else
|
|
return String.fromCharCode(parseInt(byte, 16));
|
|
}
|
|
function decodeWords(str, state) {
|
|
var pendoffset = -1;
|
|
state.replaces = [];
|
|
|
|
var bytes, m, next, i, j, leni, lenj, seq, replaces = [], lastReplace = {};
|
|
|
|
// join consecutive q-encoded words that have the same charset first
|
|
while (m = RE_ENCWORD.exec(str)) {
|
|
seq = {
|
|
consecutive: (pendoffset > -1
|
|
? RE_LWS_ONLY.test(str.substring(pendoffset, m.index))
|
|
: false),
|
|
charset: m[1].toLowerCase(),
|
|
encoding: m[2].toLowerCase(),
|
|
chunk: m[3],
|
|
index: m.index,
|
|
length: m[0].length,
|
|
pendoffset: pendoffset,
|
|
buf: undefined
|
|
};
|
|
lastReplace = replaces.length && replaces[replaces.length - 1];
|
|
if (seq.consecutive
|
|
&& seq.charset === lastReplace.charset
|
|
&& seq.encoding === lastReplace.encoding
|
|
&& seq.encoding === 'q') {
|
|
lastReplace.length += seq.length + seq.index - pendoffset;
|
|
lastReplace.chunk += seq.chunk;
|
|
} else {
|
|
replaces.push(seq);
|
|
lastReplace = seq;
|
|
}
|
|
pendoffset = m.index + m[0].length;
|
|
}
|
|
|
|
// generate replacement substrings and their positions
|
|
for (i = 0, leni = replaces.length; i < leni; ++i) {
|
|
m = replaces[i];
|
|
state.consecutive = m.consecutive;
|
|
if (m.encoding === 'q') {
|
|
// q-encoding, similar to quoted-printable
|
|
bytes = new Buffer(m.chunk.replace(RE_QENC, qEncReplacer), 'binary');
|
|
next = undefined;
|
|
} else {
|
|
// base64
|
|
bytes = m.buf || new Buffer(m.chunk, 'base64');
|
|
next = replaces[i + 1];
|
|
if (next && next.consecutive && next.encoding === m.encoding
|
|
&& next.charset === m.charset) {
|
|
// we use the next base64 chunk, if any, to determine the integrity
|
|
// of the current chunk
|
|
next.buf = new Buffer(next.chunk, 'base64');
|
|
}
|
|
}
|
|
decodeBytes(bytes, m.charset, m.index, m.length, m.pendoffset, state,
|
|
next && next.buf);
|
|
}
|
|
|
|
// perform the actual replacements
|
|
for (i = state.replaces.length - 1; i >= 0; --i) {
|
|
seq = state.replaces[i];
|
|
if (Array.isArray(seq)) {
|
|
for (j = 0, lenj = seq.length; j < lenj; ++j) {
|
|
str = str.substring(0, seq[j].fromOffset)
|
|
+ seq[j].val
|
|
+ str.substring(seq[j].toOffset);
|
|
}
|
|
} else {
|
|
str = str.substring(0, seq.fromOffset)
|
|
+ seq.val
|
|
+ str.substring(seq.toOffset);
|
|
}
|
|
}
|
|
|
|
return str;
|
|
}
|
|
|
|
function parseHeader(str, noDecode) {
|
|
var lines = str.split(RE_CRLF),
|
|
len = lines.length,
|
|
header = {},
|
|
state = {
|
|
buffer: undefined,
|
|
encoding: undefined,
|
|
consecutive: false,
|
|
replaces: undefined,
|
|
curReplace: undefined,
|
|
remainder: undefined
|
|
},
|
|
m, h, i, val;
|
|
|
|
for (i = 0; i < len; ++i) {
|
|
if (lines[i].length === 0)
|
|
break; // empty line separates message's header and body
|
|
if (lines[i][0] === '\t' || lines[i][0] === ' ') {
|
|
// folded header content
|
|
val = lines[i];
|
|
if (!noDecode) {
|
|
if (RE_ENCWORD_END.test(lines[i - 1])
|
|
&& RE_ENCWORD_BEGIN.test(val)) {
|
|
// RFC2047 says to *ignore* leading whitespace in folded header values
|
|
// for adjacent encoded-words ...
|
|
val = val.substring(1);
|
|
}
|
|
}
|
|
header[h][header[h].length - 1] += val;
|
|
} else {
|
|
m = RE_HDR.exec(lines[i]);
|
|
if (m) {
|
|
h = m[1].toLowerCase().trim();
|
|
if (m[2]) {
|
|
if (header[h] === undefined)
|
|
header[h] = [m[2]];
|
|
else
|
|
header[h].push(m[2]);
|
|
} else
|
|
header[h] = [''];
|
|
} else
|
|
break;
|
|
}
|
|
}
|
|
if (!noDecode) {
|
|
var hvs;
|
|
for (h in header) {
|
|
hvs = header[h];
|
|
for (i = 0, len = header[h].length; i < len; ++i)
|
|
hvs[i] = decodeWords(hvs[i], state);
|
|
}
|
|
}
|
|
|
|
return header;
|
|
}
|
|
|
|
exports.Parser = Parser;
|
|
exports.parseExpr = parseExpr;
|
|
exports.parseEnvelopeAddresses = parseEnvelopeAddresses;
|
|
exports.parseBodyStructure = parseBodyStructure;
|
|
exports.parseHeader = parseHeader;
|