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.
1327 lines
40 KiB
JavaScript
1327 lines
40 KiB
JavaScript
var tls = require('tls'),
|
|
Socket = require('net').Socket,
|
|
EventEmitter = require('events').EventEmitter,
|
|
inherits = require('util').inherits,
|
|
inspect = require('util').inspect,
|
|
isDate = require('util').isDate,
|
|
utf7 = require('utf7').imap;
|
|
|
|
var Parser = require('./Parser').Parser,
|
|
parseHeader = require('./Parser').parseHeader;
|
|
|
|
var MAX_INT = 9007199254740992,
|
|
KEEPALIVE_INTERVAL = 10000,
|
|
MAX_IDLE_WAIT = 300000, // 5 minutes
|
|
MONTHS = ['Jan', 'Feb', 'Mar',
|
|
'Apr', 'May', 'Jun',
|
|
'Jul', 'Aug', 'Sep',
|
|
'Oct', 'Nov', 'Dec'],
|
|
FETCH_ATTR_MAP = {
|
|
'RFC822.SIZE': 'size',
|
|
'BODY': 'struct',
|
|
'BODYSTRUCTURE': 'struct',
|
|
'UID': 'uid',
|
|
'INTERNALDATE': 'date',
|
|
'FLAGS': 'flags',
|
|
'X-GM-THRID': 'x-gm-thrid',
|
|
'X-GM-MSGID': 'x-gm-msgid',
|
|
'X-GM-LABELS': 'x-gm-labels'
|
|
},
|
|
CRLF = '\r\n',
|
|
RE_CMD = /^([^ ]+)(?: |$)/,
|
|
RE_UIDCMD_HASRESULTS = /^UID (?:FETCH|SEARCH|SORT)/,
|
|
RE_IDLENOOPRES = /^(IDLE|NOOP) /,
|
|
RE_OPENBOX = /^EXAMINE|SELECT$/,
|
|
RE_BODYPART = /^BODY\[/,
|
|
RE_INVALID_KW_CHARS = /[\(\)\{\\\"\]\%\*\x00-\x20\x7F]/,
|
|
RE_NUM_RANGE = /^(?:[\d]+|\*):(?:[\d]+|\*)$/,
|
|
RE_BACKSLASH = /\\/g,
|
|
RE_BACKSLASH_ESC = /\\\\/g,
|
|
RE_DBLQUOTE = /"/g,
|
|
RE_DBLQUOTE_ESC = /\\"/g,
|
|
RE_INTEGER = /^\d+$/;
|
|
|
|
function Connection(config) {
|
|
if (!(this instanceof Connection))
|
|
return new Connection(config);
|
|
|
|
EventEmitter.call(this);
|
|
|
|
config || (config = {});
|
|
|
|
this._config = {
|
|
host: config.host || 'localhost',
|
|
port: config.port || 143,
|
|
secure: (config.secure === true ? 'implicit' : config.secure),
|
|
secureOptions: config.secureOptions,
|
|
user: config.user,
|
|
password: config.password,
|
|
connTimeout: config.connTimeout || 10000,
|
|
keepalive: (typeof config.keepalive === 'boolean'
|
|
? config.keepalive
|
|
: true)
|
|
};
|
|
|
|
this._sock = undefined;
|
|
this._tagcount = 0;
|
|
this._tmrConn = undefined;
|
|
this._queue = [];
|
|
this._box = undefined;
|
|
this._idle = {};
|
|
this.delimiter = undefined;
|
|
this.namespaces = undefined;
|
|
this.state = 'disconnected';
|
|
this.debug = config.debug;
|
|
}
|
|
inherits(Connection, EventEmitter);
|
|
|
|
Connection.prototype.connect = function() {
|
|
var config = this._config, self = this, socket, tlsSocket, parser, tlsOptions;
|
|
|
|
socket = new Socket();
|
|
socket.setKeepAlive(true);
|
|
socket.setTimeout(0);
|
|
this._state = 'disconnected';
|
|
|
|
if (config.secure) {
|
|
tlsOptions = {};
|
|
for (var k in config.secureOptions)
|
|
tlsOptions[k] = config.secureOptions[k];
|
|
tlsOptions.socket = socket;
|
|
}
|
|
|
|
if (config.secure === 'implicit')
|
|
this._sock = tlsSocket = tls.connect(tlsOptions, onconnect);
|
|
else {
|
|
socket.once('connect', onconnect);
|
|
this._sock = socket;
|
|
}
|
|
|
|
function onconnect() {
|
|
clearTimeout(self._tmrConn);
|
|
self.state = 'connected';
|
|
self.debug&&self.debug('[connection] Connected to host');
|
|
}
|
|
|
|
this._sock.once('error', function(err) {
|
|
clearTimeout(self._tmrConn);
|
|
clearTimeout(self._tmrKeepalive);
|
|
self.debug&&self.debug('[connection] Error: ' + err);
|
|
err.source = 'socket';
|
|
self.emit('error', err);
|
|
});
|
|
|
|
socket.once('close', function(had_err) {
|
|
clearTimeout(self._tmrConn);
|
|
clearTimeout(self._tmrKeepalive);
|
|
self.debug&&self.debug('[connection] Closed');
|
|
self.emit('close', had_err);
|
|
});
|
|
|
|
socket.once('end', function() {
|
|
clearTimeout(self._tmrConn);
|
|
clearTimeout(self._tmrKeepalive);
|
|
self.debug&&self.debug('[connection] Ended');
|
|
self.emit('end');
|
|
});
|
|
|
|
parser = new Parser(this._sock, this.debug);
|
|
|
|
parser.on('untagged', function(info) {
|
|
self._resUntagged(info);
|
|
});
|
|
parser.on('tagged', function(info) {
|
|
self._resTagged(info);
|
|
});
|
|
parser.on('body', function(stream, info) {
|
|
var msg = self._curReq.fetchCache[info.seqno], toget;
|
|
|
|
if (msg === undefined) {
|
|
msg = self._curReq.fetchCache[info.seqno] = {
|
|
msgEmitter: new EventEmitter(),
|
|
toget: self._curReq.fetching.slice(0),
|
|
attrs: {},
|
|
ended: false
|
|
};
|
|
|
|
self._curReq.bodyEmitter.emit('message', msg.msgEmitter, info.seqno);
|
|
}
|
|
|
|
toget = msg.toget;
|
|
|
|
var idx = toget.indexOf('BODY[' + info.which + ']');
|
|
if (idx > -1) {
|
|
toget.splice(idx, 1);
|
|
msg.msgEmitter.emit('body', stream, info);
|
|
} else
|
|
stream.resume(); // a body we didn't ask for?
|
|
});
|
|
parser.on('continue', function(info) {
|
|
// only needed for IDLE and APPEND
|
|
var type = self._curReq.type;
|
|
if (type === 'IDLE') {
|
|
// now idling
|
|
self._idle.started = Date.now();
|
|
} else if (/^AUTHENTICATE XOAUTH/.test(self._curReq.fullcmd)) {
|
|
self._curReq.oauthError = new Buffer(info.text, 'base64').toString('utf8');
|
|
self._sock.write(CRLF);
|
|
} else if (type === 'APPEND')
|
|
self._sock.write(self._curReq.appendData);
|
|
});
|
|
parser.on('other', function(line) {
|
|
var m;
|
|
if (m = RE_IDLENOOPRES.exec(line)) {
|
|
if (m[1] === 'IDLE') {
|
|
// no longer idling
|
|
self._idle.enabled = false;
|
|
self._idle.started = undefined;
|
|
}
|
|
|
|
self._curReq = undefined;
|
|
|
|
if (self._queue.length === 0
|
|
&& self._config.keepalive
|
|
&& self.state === 'authenticated') {
|
|
self._idle.enabled = true;
|
|
self._doKeepaliveTimer(true);
|
|
}
|
|
|
|
self._processQueue();
|
|
}
|
|
});
|
|
|
|
this._tmrConn = setTimeout(function() {
|
|
var err = new Error('Connection timed out');
|
|
err.source = 'timeout';
|
|
self.emit('error', err);
|
|
socket.destroy();
|
|
}, config.connTimeout);
|
|
|
|
socket.connect(config.port, config.host);
|
|
};
|
|
|
|
Connection.prototype.serverSupports = function(cap) {
|
|
return (this._caps && this._caps.indexOf(cap) > -1);
|
|
};
|
|
|
|
Connection.prototype.end = function() {
|
|
this._sock.end();
|
|
};
|
|
|
|
Connection.prototype.append = function(data, options, cb) {
|
|
if (typeof options === 'function') {
|
|
cb = options;
|
|
options = undefined;
|
|
}
|
|
options = options || {};
|
|
if (!options.mailbox) {
|
|
if (!this._box)
|
|
throw new Error('No mailbox specified or currently selected');
|
|
else
|
|
options.mailbox = this._box.name;
|
|
}
|
|
var cmd = 'APPEND "' + escape(utf7.encode(''+options.mailbox)) + '"';
|
|
if (options.flags) {
|
|
if (!Array.isArray(options.flags))
|
|
options.flags = [options.flags];
|
|
if (options.flags.length > 0)
|
|
cmd += ' (\\' + options.flags.join(' \\') + ')';
|
|
}
|
|
if (options.date) {
|
|
if (!isDate(options.date))
|
|
throw new Error('`date` is not a Date object');
|
|
cmd += ' "';
|
|
cmd += options.date.getDate();
|
|
cmd += '-';
|
|
cmd += MONTHS[options.date.getMonth()];
|
|
cmd += '-';
|
|
cmd += options.date.getFullYear();
|
|
cmd += ' ';
|
|
cmd += ('0' + options.date.getHours()).slice(-2);
|
|
cmd += ':';
|
|
cmd += ('0' + options.date.getMinutes()).slice(-2);
|
|
cmd += ':';
|
|
cmd += ('0' + options.date.getSeconds()).slice(-2);
|
|
cmd += ((options.date.getTimezoneOffset() > 0) ? ' -' : ' +' );
|
|
cmd += ('0' + (-options.date.getTimezoneOffset() / 60)).slice(-2);
|
|
cmd += ('0' + (-options.date.getTimezoneOffset() % 60)).slice(-2);
|
|
cmd += '"';
|
|
}
|
|
cmd += ' {';
|
|
cmd += (Buffer.isBuffer(data) ? data.length : Buffer.byteLength(data));
|
|
cmd += '}';
|
|
|
|
this._enqueue(cmd, cb);
|
|
this._queue[this._queue.length - 1].appendData = data;
|
|
};
|
|
|
|
Connection.prototype.getBoxes = function(namespace, cb) {
|
|
if (typeof namespace === 'function') {
|
|
cb = namespace;
|
|
namespace = '';
|
|
}
|
|
|
|
namespace = escape(utf7.encode(''+namespace));
|
|
|
|
this._enqueue('LIST "' + namespace + '" "*"', cb);
|
|
};
|
|
|
|
Connection.prototype.openBox = function(name, readOnly, cb) {
|
|
if (this.state !== 'authenticated')
|
|
throw new Error('Not authenticated');
|
|
|
|
if (cb === undefined) {
|
|
cb = readOnly;
|
|
readOnly = false;
|
|
}
|
|
|
|
name = ''+name;
|
|
var encname = escape(utf7.encode(name)),
|
|
cmd = (readOnly ? 'EXAMINE' : 'SELECT'),
|
|
self = this;
|
|
|
|
this._enqueue(cmd + ' "' + encname + '"', function(err) {
|
|
if (err) {
|
|
self._box = undefined;
|
|
cb(err);
|
|
} else {
|
|
self._box.name = name;
|
|
cb(err, self._box);
|
|
}
|
|
});
|
|
};
|
|
|
|
// also deletes any messages in this box marked with \Deleted
|
|
Connection.prototype.closeBox = function(cb) {
|
|
var self = this;
|
|
if (this._box === undefined)
|
|
throw new Error('No mailbox is currently selected');
|
|
|
|
this._enqueue('CLOSE', function(err) {
|
|
if (!err)
|
|
self._box = undefined;
|
|
|
|
cb(err);
|
|
});
|
|
};
|
|
|
|
Connection.prototype.addBox = function(name, cb) {
|
|
this._enqueue('CREATE "' + escape(utf7.encode(''+name)) + '"', cb);
|
|
};
|
|
|
|
Connection.prototype.delBox = function(name, cb) {
|
|
this._enqueue('DELETE "' + escape(utf7.encode(''+name)) + '"', cb);
|
|
};
|
|
|
|
Connection.prototype.renameBox = function(oldname, newname, cb) {
|
|
var destname = newname;
|
|
if (this._box
|
|
&& oldname === this._box.name
|
|
&& oldname.toUpperCase() !== 'INBOX')
|
|
destname = ''+oldname;
|
|
|
|
var encoldname = escape(utf7.encode(''+oldname)),
|
|
encnewname = escape(utf7.encode(''+newname)),
|
|
self = this;
|
|
|
|
this._enqueue('RENAME "' + encoldname + '" "' + encnewname + '"',
|
|
function(err) {
|
|
if (err)
|
|
return cb(err);
|
|
self._box.name = destname;
|
|
cb(err, self._box);
|
|
}
|
|
);
|
|
};
|
|
|
|
Connection.prototype.status = function(boxName, cb) {
|
|
if (this._box && this._box.name === boxName)
|
|
throw new Error('Cannot call status on currently selected mailbox');
|
|
|
|
boxName = escape(utf7.encode(''+boxName));
|
|
|
|
this._enqueue('STATUS "' + boxName + '" (MESSAGES RECENT UNSEEN UIDVALIDITY)',
|
|
cb);
|
|
};
|
|
|
|
Connection.prototype.removeDeleted = function(uids, cb) {
|
|
if (typeof uids === 'function') {
|
|
cb = uids;
|
|
uids = undefined;
|
|
}
|
|
|
|
if (uids !== undefined) {
|
|
if (!Array.isArray(uids))
|
|
uids = [uids];
|
|
|
|
validateUIDList(uids);
|
|
uids = uids.join(',');
|
|
|
|
this._enqueue('UID EXPUNGE ' + uids, cb);
|
|
} else
|
|
this._enqueue('EXPUNGE', cb);
|
|
};
|
|
|
|
Connection.prototype.search = function(options, cb) {
|
|
this._search('UID ', options, cb);
|
|
};
|
|
|
|
Connection.prototype._search = function(which, options, cb) {
|
|
if (this._box === undefined)
|
|
throw new Error('No mailbox is currently selected');
|
|
else if (!Array.isArray(options))
|
|
throw new Error('Expected array for search options');
|
|
|
|
this._enqueue(which + 'SEARCH' + buildSearchQuery(options, this._caps), cb);
|
|
};
|
|
|
|
Connection.prototype.sort = function(sorts, options, cb) {
|
|
this._sort('UID ', sorts, options, cb);
|
|
};
|
|
|
|
Connection.prototype._sort = function(which, sorts, options, cb) {
|
|
if (this._box === undefined)
|
|
throw new Error('No mailbox is currently selected');
|
|
else if (!Array.isArray(sorts) || !sorts.length)
|
|
throw new Error('Expected array with at least one sort criteria');
|
|
else if (!Array.isArray(options))
|
|
throw new Error('Expected array for search options');
|
|
else if (!this.serverSupports('SORT'))
|
|
throw new Error('Sort is not supported on the server');
|
|
|
|
var criteria = sorts.map(function(c) {
|
|
if (typeof c !== 'string')
|
|
throw new Error('Unexpected sort criteria data type. '
|
|
+ 'Expected string. Got: ' + typeof criteria);
|
|
|
|
var modifier = '';
|
|
if (c[0] === '-') {
|
|
modifier = 'REVERSE ';
|
|
c = c.substring(1);
|
|
}
|
|
switch (c.toUpperCase()) {
|
|
case 'ARRIVAL':
|
|
case 'CC':
|
|
case 'DATE':
|
|
case 'FROM':
|
|
case 'SIZE':
|
|
case 'SUBJECT':
|
|
case 'TO':
|
|
break;
|
|
default:
|
|
throw new Error('Unexpected sort criteria: ' + c);
|
|
}
|
|
|
|
return modifier + c;
|
|
});
|
|
|
|
this._enqueue(which + 'SORT (' + criteria.join(' ') + ') UTF-8'
|
|
+ buildSearchQuery(options, this._caps), cb);
|
|
};
|
|
|
|
Connection.prototype.addFlags = function(uids, flags, cb) {
|
|
this._store('UID ', uids, flags, true, cb);
|
|
};
|
|
|
|
Connection.prototype.delFlags = function(uids, flags, cb) {
|
|
this._store('UID ', uids, flags, false, cb);
|
|
};
|
|
|
|
Connection.prototype.addKeywords = function(uids, flags, cb) {
|
|
this._addKeywords('UID ', uids, flags, cb);
|
|
};
|
|
|
|
Connection.prototype._addKeywords = function(which, uids, flags, cb) {
|
|
if (this._box && !this._box.newKeywords)
|
|
throw new Error('This mailbox does not allow new keywords to be added');
|
|
this._store(which, uids, flags, true, cb);
|
|
};
|
|
|
|
Connection.prototype.delKeywords = function(uids, flags, cb) {
|
|
this._store('UID ', uids, flags, false, cb);
|
|
};
|
|
|
|
Connection.prototype._store = function(which, uids, flags, isAdding, cb) {
|
|
var isKeywords = (arguments.callee.caller === this._addKeywords
|
|
|| arguments.callee.caller === this.delKeywords);
|
|
if (this._box === undefined)
|
|
throw new Error('No mailbox is currently selected');
|
|
else if (uids === undefined)
|
|
throw new Error('No messages specified');
|
|
|
|
if (!Array.isArray(uids))
|
|
uids = [uids];
|
|
validateUIDList(uids);
|
|
|
|
if ((!Array.isArray(flags) && typeof flags !== 'string')
|
|
|| (Array.isArray(flags) && flags.length === 0))
|
|
throw new Error((isKeywords ? 'Keywords' : 'Flags')
|
|
+ ' argument must be a string or a non-empty Array');
|
|
if (!Array.isArray(flags))
|
|
flags = [flags];
|
|
for (var i = 0, len = flags.length; i < len; ++i) {
|
|
if (!isKeywords) {
|
|
if (flags[i][0] === '\\')
|
|
flags[i] = flags[i].substr(1);
|
|
if (this._state.box.permFlags.indexOf(flags[i].toLowerCase()) === -1
|
|
|| flags[i] === '*')
|
|
throw new Error('The flag "' + flags[i]
|
|
+ '" is not allowed by the server for this mailbox');
|
|
flags[i] = '\\' + flags[i];
|
|
} else {
|
|
// keyword contains any char except control characters (%x00-1F and %x7F)
|
|
// and: '(', ')', '{', ' ', '%', '*', '\', '"', ']'
|
|
if (RE_INVALID_KW_CHARS.test(flags[i])) {
|
|
throw new Error('The keyword "' + flags[i]
|
|
+ '" contains invalid characters');
|
|
}
|
|
}
|
|
}
|
|
|
|
flags = flags.join(' ');
|
|
uids = uids.join(',');
|
|
|
|
|
|
this._enqueue(which + 'STORE ' + uids + ' ' + (isAdding ? '+' : '-')
|
|
+ 'FLAGS.SILENT (' + flags + ')', cb);
|
|
};
|
|
|
|
Connection.prototype.setLabels = function(uids, labels, cb) {
|
|
this._storeLabels('UID ', uids, labels, '', cb);
|
|
};
|
|
|
|
Connection.prototype.addLabels = function(uids, labels, cb) {
|
|
this._storeLabels('UID ', uids, labels, '+', cb);
|
|
};
|
|
|
|
Connection.prototype.delLabels = function(uids, labels, cb) {
|
|
this._storeLabels('UID ', uids, labels, '-', cb);
|
|
};
|
|
|
|
Connection.prototype._storeLabels = function(which, uids, labels, mode, cb) {
|
|
if (!this.serverSupports('X-GM-EXT-1'))
|
|
throw new Error('Server must support X-GM-EXT-1 capability');
|
|
else if (this._box === undefined)
|
|
throw new Error('No mailbox is currently selected');
|
|
else if (uids === undefined)
|
|
throw new Error('No messages specified');
|
|
|
|
if (!Array.isArray(uids))
|
|
uids = [uids];
|
|
validateUIDList(uids);
|
|
|
|
if ((!Array.isArray(labels) && typeof labels !== 'string')
|
|
|| (Array.isArray(labels) && labels.length === 0))
|
|
throw new Error('labels argument must be a string or a non-empty Array');
|
|
|
|
if (!Array.isArray(labels))
|
|
labels = [labels];
|
|
labels = labels.map(function(v) {
|
|
return '"' + escape(utf7.encode(''+v)) + '"';
|
|
}).join(' ');
|
|
|
|
uids = uids.join(',');
|
|
|
|
this._enqueue(which + 'STORE ' + uids + ' ' + mode
|
|
+ 'X-GM-LABELS.SILENT (' + labels + ')', cb);
|
|
};
|
|
|
|
Connection.prototype.copy = function(uids, boxTo, cb) {
|
|
this._copy('UID ', uids, boxTo, cb);
|
|
};
|
|
|
|
Connection.prototype._copy = function(which, uids, boxTo, cb) {
|
|
if (this._box === undefined)
|
|
throw new Error('No mailbox is currently selected');
|
|
|
|
if (!Array.isArray(uids))
|
|
uids = [uids];
|
|
|
|
validateUIDList(uids);
|
|
boxTo = escape(utf7.encode(''+boxTo));
|
|
|
|
this._enqueue(which + 'COPY ' + uids.join(',') + ' "'
|
|
+ boxTo + '"', cb);
|
|
};
|
|
|
|
Connection.prototype.move = function(uids, boxTo, cb) {
|
|
this._move('UID ', uids, boxTo, cb);
|
|
};
|
|
|
|
Connection.prototype._move = function(which, uids, boxTo, cb) {
|
|
if (this._box === undefined)
|
|
throw new Error('No mailbox is currently selected');
|
|
|
|
if (this.serverSupports('MOVE')) {
|
|
if (!Array.isArray(uids))
|
|
uids = [uids];
|
|
|
|
validateUIDList(uids);
|
|
uids = uids.join(',');
|
|
boxTo = escape(utf7.encode(''+boxTo));
|
|
|
|
this._enqueue(which + 'MOVE ' + uids + ' "' + boxTo + '"', cb);
|
|
} else if (this._box.permFlags.indexOf('deleted') === -1) {
|
|
throw new Error('Cannot move message: '
|
|
+ 'server does not allow deletion of messages');
|
|
} else {
|
|
var deletedUIDs, task = 0, self = this;
|
|
this._copy(which, uids, boxTo, function ccb(err, info) {
|
|
if (err)
|
|
return cb(err, info);
|
|
|
|
if (task === 0 && which && self.serverSupports('UIDPLUS')) {
|
|
// UIDPLUS gives us a 'UID EXPUNGE n' command to expunge a subset of
|
|
// messages with the \Deleted flag set. This allows us to skip some
|
|
// actions.
|
|
task = 2;
|
|
}
|
|
// Make sure we don't expunge any messages marked as Deleted except the
|
|
// one we are moving
|
|
if (task === 0) {
|
|
self.search(['DELETED'], function(e, result) {
|
|
++task;
|
|
deletedUIDs = result;
|
|
ccb(e, info);
|
|
});
|
|
} else if (task === 1) {
|
|
if (deletedUIDs.length) {
|
|
self.delFlags(deletedUIDs, 'Deleted', function(e) {
|
|
++task;
|
|
ccb(e, info);
|
|
});
|
|
} else {
|
|
++task;
|
|
ccb(err, info);
|
|
}
|
|
} else if (task === 2) {
|
|
function cbMarkDel(e) {
|
|
++task;
|
|
ccb(e, info);
|
|
}
|
|
if (which)
|
|
self.addFlags(uids, 'Deleted', cbMarkDel);
|
|
else
|
|
self.seq.addFlags(uids, 'Deleted', cbMarkDel);
|
|
} else if (task === 3) {
|
|
if (which && self.serverSupports('UIDPLUS'))
|
|
self.removeDeleted(uids, cb);
|
|
else {
|
|
self.removeDeleted(function(e) {
|
|
++task;
|
|
ccb(e, info);
|
|
});
|
|
}
|
|
} else if (task === 4) {
|
|
if (deletedUIDs.length) {
|
|
self.addFlags(deletedUIDs, 'Deleted', function(e) {
|
|
cb(e, info);
|
|
});
|
|
} else
|
|
cb(err, info);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
Connection.prototype.fetch = function(uids, options) {
|
|
return this._fetch('UID ', uids, options);
|
|
};
|
|
|
|
Connection.prototype._fetch = function(which, uids, options) {
|
|
if (uids === undefined
|
|
|| uids === null
|
|
|| (Array.isArray(uids) && uids.length === 0))
|
|
throw new Error('Nothing to fetch');
|
|
|
|
if (!Array.isArray(uids))
|
|
uids = [uids];
|
|
validateUIDList(uids);
|
|
uids = uids.join(',');
|
|
|
|
var cmd = which + 'FETCH ' + uids + ' (', fetching = [];
|
|
|
|
// always fetch GMail-specific bits of information when on GMail
|
|
if (this.serverSupports('X-GM-EXT-1')) {
|
|
fetching.push('X-GM-THRID');
|
|
fetching.push('X-GM-MSGID');
|
|
fetching.push('X-GM-LABELS');
|
|
}
|
|
|
|
fetching.push('UID');
|
|
fetching.push('FLAGS');
|
|
fetching.push('INTERNALDATE');
|
|
|
|
if (options) {
|
|
if (options.struct)
|
|
fetching.push('BODYSTRUCTURE');
|
|
if (options.size)
|
|
fetching.push('RFC822.SIZE');
|
|
cmd += fetching.join(' ');
|
|
if (options.bodies !== undefined) {
|
|
var bodies = options.bodies,
|
|
prefix = (options.markSeen ? '' : '.PEEK');
|
|
if (!Array.isArray(bodies))
|
|
bodies = [bodies];
|
|
for (var i = 0, len = bodies.length; i < len; ++i) {
|
|
fetching.push('BODY[' + bodies[i] + ']');
|
|
cmd += ' BODY' + prefix + '[' + bodies[i] + ']';
|
|
}
|
|
}
|
|
} else
|
|
cmd += fetching.join(' ');
|
|
|
|
cmd += ')';
|
|
|
|
this._enqueue(cmd);
|
|
var req = this._queue[this._queue.length - 1];
|
|
req.fetchCache = {};
|
|
req.fetching = fetching;
|
|
return (req.bodyEmitter = new EventEmitter());
|
|
};
|
|
|
|
// Namespace for seqno-based commands
|
|
Connection.prototype.__defineGetter__('seq', function() {
|
|
var self = this;
|
|
return {
|
|
move: function(seqnos, boxTo, cb) {
|
|
self._move('', seqnos, boxTo, cb);
|
|
},
|
|
copy: function(seqnos, boxTo, cb) {
|
|
self._copy('', seqnos, boxTo, cb);
|
|
},
|
|
delKeywords: function(seqnos, flags, cb) {
|
|
self._store('', seqnos, flags, false, cb);
|
|
},
|
|
addKeywords: function(seqnos, flags, cb) {
|
|
self._addKeywords('', seqnos, flags, cb);
|
|
},
|
|
delFlags: function(seqnos, flags, cb) {
|
|
self._store('', seqnos, flags, false, cb);
|
|
},
|
|
addFlags: function(seqnos, flags, cb) {
|
|
self._store('', seqnos, flags, true, cb);
|
|
},
|
|
delLabels: function(seqnos, labels, cb) {
|
|
self._storeLabels('', seqnos, labels, '-', cb);
|
|
},
|
|
addLabels: function(seqnos, labels, cb) {
|
|
self._storeLabels('', seqnos, labels, '+', cb);
|
|
},
|
|
setLabels: function(seqnos, labels, cb) {
|
|
self._storeLabels('', seqnos, labels, '', cb);
|
|
},
|
|
fetch: function(seqnos, options, what, cb) {
|
|
return self._fetch('', seqnos, options, what, cb);
|
|
},
|
|
search: function(options, cb) {
|
|
self._search('', options, cb);
|
|
},
|
|
sort: function(sorts, options, cb) {
|
|
self._sort('', sorts, options, cb);
|
|
}
|
|
};
|
|
});
|
|
|
|
Connection.prototype._resUntagged = function(info) {
|
|
var type = info.type;
|
|
|
|
if (type === 'bye')
|
|
this._sock.end();
|
|
else if (type === 'namespace')
|
|
this.namespaces = info.text;
|
|
else if (type === 'capability')
|
|
this._caps = info.text.map(function(v) { return v.toUpperCase(); });
|
|
else if (type === 'preauth')
|
|
this.state = 'authenticated';
|
|
else if (type === 'search' || type === 'sort')
|
|
this._curReq.cbargs.push(info.text);
|
|
else if (type === 'recent') {
|
|
if (!this._box && RE_OPENBOX.test(this._curReq.type))
|
|
this._createCurrentBox();
|
|
this._box.messages.new = info.num;
|
|
}
|
|
else if (type === 'flags') {
|
|
if (!this._box && RE_OPENBOX.test(this._curReq.type))
|
|
this._createCurrentBox();
|
|
this._box.flags = info.text;
|
|
} else if (type === 'bad' || type === 'no') {
|
|
if (this.state === 'connected' && !this._curReq) {
|
|
clearTimeout(this._tmrConn);
|
|
var err = new Error('Received negative welcome: ' + info.text);
|
|
err.level = 'protocol';
|
|
this.emit('error', err);
|
|
this._sock.end();
|
|
}
|
|
} else if (type === 'exists') {
|
|
if (!this._box && RE_OPENBOX.test(this._curReq.type))
|
|
this._createCurrentBox();
|
|
var prev = this._box.messages.total,
|
|
now = info.num;
|
|
this._box.messages.total = now;
|
|
if (now > prev && this.state === 'authenticated') {
|
|
this._box.messages.new = now - prev;
|
|
this.emit('mail', this._box.messages.total);
|
|
}
|
|
} else if (type === 'expunge') {
|
|
if (this._box.messages.total > 0)
|
|
--this._box.messages.total;
|
|
if (!this._curReq)
|
|
this.emit('deleted', info.num);
|
|
} else if (type === 'ok') {
|
|
if (this.state === 'connected' && !this._curReq)
|
|
this._login();
|
|
else if (typeof info.textCode === 'string'
|
|
&& info.textCode.toUpperCase() === 'ALERT')
|
|
this.emit('alert', info.text);
|
|
else if (this._curReq
|
|
&& typeof info.textCode === 'object'
|
|
&& (RE_OPENBOX.test(this._curReq.type))) {
|
|
// we're opening a mailbox
|
|
|
|
if (!this._box)
|
|
this._createCurrentBox();
|
|
|
|
var key = info.textCode.key.toUpperCase();
|
|
|
|
if (key === 'UIDVALIDITY')
|
|
this._box.uidvalidity = info.textCode.val;
|
|
else if (key === 'UIDNEXT')
|
|
this._box.uidnext = info.textCode.val;
|
|
else if (key === 'PERMANENTFLAGS') {
|
|
var idx, permFlags, keywords;
|
|
this._box.permFlags = permFlags = info.textCode.val;
|
|
if ((idx = this._box.permFlags.indexOf('\\*')) > -1) {
|
|
this._box.newKeywords = true;
|
|
permFlags.splice(idx, 1);
|
|
}
|
|
this._box.keywords = keywords = permFlags.filter(function(f) {
|
|
return (f[0] !== '\\');
|
|
});
|
|
for (var i = 0, len = keywords.length; i < len; ++i)
|
|
permFlags.splice(permFlags.indexOf(keywords[i]), 1);
|
|
this._box.permFlags = permFlags.map(function(f) {
|
|
return f.substr(1).toLowerCase();
|
|
});
|
|
}
|
|
}
|
|
} else if (type === 'list') {
|
|
if (this.delimiter === undefined)
|
|
this.delimiter = info.text.delimiter;
|
|
else {
|
|
if (this._curReq.cbargs.length === 0)
|
|
this._curReq.cbargs.push({});
|
|
|
|
var box = {
|
|
attribs: info.text.flags.map(function(attr) {
|
|
return attr.substr(1);
|
|
}).filter(function(attr) {
|
|
return (attr.toUpperCase() !== 'HASNOCHILDREN');
|
|
}),
|
|
delimiter: info.text.delimiter,
|
|
children: null,
|
|
parent: null
|
|
},
|
|
name = info.text.name,
|
|
curChildren = this._curReq.cbargs[0];
|
|
|
|
if (box.delimiter) {
|
|
var path = name.split(box.delimiter),
|
|
parent = null;
|
|
name = path.pop();
|
|
for (var i = 0, len = path.length; i < len; ++i) {
|
|
if (!curChildren[path[i]])
|
|
curChildren[path[i]] = {};
|
|
if (!curChildren[path[i]].children)
|
|
curChildren[path[i]].children = {};
|
|
parent = curChildren[path[i]];
|
|
curChildren = curChildren[path[i]].children;
|
|
}
|
|
box.parent = parent;
|
|
}
|
|
if (curChildren[name])
|
|
box.children = curChildren[name].children;
|
|
curChildren[name] = box;
|
|
}
|
|
} else if (type === 'status') {
|
|
var box = {
|
|
name: info.text.name,
|
|
uidvalidity: 0,
|
|
messages: {
|
|
total: 0,
|
|
new: 0,
|
|
unseen: 0
|
|
}
|
|
}, attrs = info.text.attrs;
|
|
|
|
if (attrs) {
|
|
if (attrs.recent !== undefined)
|
|
box.messages.new = attrs.recent;
|
|
if (attrs.unseen !== undefined)
|
|
box.messages.unseen = attrs.unseen;
|
|
if (attrs.messages !== undefined)
|
|
box.messages.total = attrs.messages;
|
|
if (attrs.uidvalidity !== undefined)
|
|
box.uidvalidity = attrs.uidvalidity;
|
|
}
|
|
this._curReq.cbargs.push(box);
|
|
} else if (type === 'fetch') {
|
|
var msg = this._curReq.fetchCache[info.num],
|
|
keys = Object.keys(info.text),
|
|
keyslen = keys.length,
|
|
attrs, toget, msgEmitter, i, j;
|
|
|
|
if (msg === undefined) {
|
|
// simple case -- no bodies were streamed
|
|
toget = this._curReq.fetching.slice(0);
|
|
if (toget.length === 0)
|
|
return;
|
|
|
|
msgEmitter = new EventEmitter();
|
|
attrs = {};
|
|
|
|
this._curReq.bodyEmitter.emit('message', msgEmitter, info.num);
|
|
} else {
|
|
toget = msg.toget;
|
|
msgEmitter = msg.msgEmitter;
|
|
attrs = msg.attrs;
|
|
}
|
|
|
|
i = toget.length;
|
|
if (i === 0) {
|
|
if (!msg.ended) {
|
|
msg.ended = true;
|
|
msgEmitter.emit('end');
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (keyslen > 0) {
|
|
while (--i >= 0) {
|
|
j = keyslen;
|
|
while (--j >= 0) {
|
|
if (keys[j].toUpperCase() === toget[i]) {
|
|
if (!RE_BODYPART.test(toget[i]))
|
|
attrs[FETCH_ATTR_MAP[toget[i]]] = info.text[keys[j]];
|
|
toget.splice(i, 1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (toget.length === 0) {
|
|
msgEmitter.emit('attributes', attrs);
|
|
msgEmitter.emit('end');
|
|
} else if (msg === undefined) {
|
|
this._curReq.fetchCache[info.num] = {
|
|
msgEmitter: msgEmitter,
|
|
toget: toget,
|
|
attrs: attrs,
|
|
ended: false
|
|
};
|
|
}
|
|
}
|
|
};
|
|
|
|
Connection.prototype._resTagged = function(info) {
|
|
var req = this._curReq, err;
|
|
|
|
this._curReq = undefined;
|
|
|
|
if (info.type === 'no' || info.type === 'bad') {
|
|
var errtext;
|
|
if (/^AUTHENTICATE XOAUTH/.test(req.fullcmd) && req.oauthError)
|
|
errtext = req.oauthError;
|
|
else
|
|
errtext = info.text;
|
|
var err = new Error(errtext);
|
|
err.textCode = info.textCode;
|
|
err.source = 'protocol';
|
|
} else if (this._box) {
|
|
if (req.type === 'EXAMINE' || req.type === 'SELECT') {
|
|
this._box.readOnly = (typeof info.textCode === 'string'
|
|
&& info.textCode.toUpperCase() === 'READ-ONLY');
|
|
}
|
|
|
|
// According to RFC 3501, UID commands do not give errors for
|
|
// non-existant user-supplied UIDs, so give the callback empty results
|
|
// if we unexpectedly received no untagged responses.
|
|
if (RE_UIDCMD_HASRESULTS.test(req.fullcmd) && req.cbargs.length === 0)
|
|
req.cbargs.push([]);
|
|
}
|
|
|
|
if (req.bodyEmitter) {
|
|
if (err)
|
|
req.bodyEmitter.emit('error', err);
|
|
req.bodyEmitter.emit('end');
|
|
} else {
|
|
req.cbargs.unshift(err);
|
|
req.cb && req.cb.apply(this, req.cbargs);
|
|
}
|
|
|
|
if (this._queue.length === 0
|
|
&& this._config.keepalive
|
|
&& this.state === 'authenticated') {
|
|
this._idle.enabled = true;
|
|
this._doKeepaliveTimer(true);
|
|
}
|
|
|
|
this._processQueue();
|
|
};
|
|
|
|
Connection.prototype._createCurrentBox = function() {
|
|
this._box = {
|
|
name: '',
|
|
flags: [],
|
|
readOnly: false,
|
|
uidvalidity: 0,
|
|
uidnext: 0,
|
|
permFlags: [],
|
|
keywords: [],
|
|
newKeywords: false,
|
|
messages: {
|
|
total: 0,
|
|
new: 0
|
|
}
|
|
};
|
|
};
|
|
|
|
Connection.prototype._doKeepaliveTimer = function(immediate) {
|
|
var self = this,
|
|
timerfn = function() {
|
|
if (self._idle.enabled) {
|
|
// unlike NOOP, IDLE is only a valid command after authenticating
|
|
if (!self.serverSupports('IDLE') || self.state !== 'authenticated')
|
|
self._enqueue('NOOP', true);
|
|
else {
|
|
if (self._idle.started === undefined) {
|
|
self._idle.started = 0;
|
|
self._enqueue('IDLE', true);
|
|
} else if (self._idle.started > 0) {
|
|
var timeDiff = Date.now() - self._idle.started;
|
|
if (timeDiff >= MAX_IDLE_WAIT) {
|
|
self._idle.enabled = false;
|
|
self.debug && self.debug('=> DONE');
|
|
self._sock.write('DONE' + CRLF);
|
|
return;
|
|
}
|
|
}
|
|
self._doKeepaliveTimer();
|
|
}
|
|
}
|
|
};
|
|
|
|
if (immediate)
|
|
timerfn();
|
|
else
|
|
this._tmrKeepalive = setTimeout(timerfn, KEEPALIVE_INTERVAL);
|
|
};
|
|
|
|
Connection.prototype._login = function() {
|
|
var self = this, checkedNS = false;
|
|
|
|
var reentry = function(err) {
|
|
if (err) {
|
|
self.emit('error', err);
|
|
return self._sock.destroy();
|
|
}
|
|
|
|
// 2. Get the list of available namespaces (RFC2342)
|
|
if (!checkedNS && self.serverSupports('NAMESPACE')) {
|
|
checkedNS = true;
|
|
return self._enqueue('NAMESPACE', reentry);
|
|
}
|
|
|
|
// 3. Get the top-level mailbox hierarchy delimiter used by the server
|
|
self._enqueue('LIST "" ""', function() {
|
|
self.state = 'authenticated';
|
|
self.emit('ready');
|
|
});
|
|
};
|
|
|
|
// 1. Get the supported capabilities
|
|
self._enqueue('CAPABILITY', function() {
|
|
// No need to attempt the login sequence if we're on a PREAUTH connection.
|
|
if (self.state === 'connected') {
|
|
var err,
|
|
checkCaps = function(error) {
|
|
if (error) {
|
|
error.source = 'authentication';
|
|
return reentry(error);
|
|
}
|
|
|
|
if (self._caps === undefined) {
|
|
// Fetch server capabilities if they were not automatically
|
|
// provided after authentication
|
|
return self._enqueue('CAPABILITY', reentry);
|
|
} else
|
|
reentry();
|
|
};
|
|
|
|
if (self.serverSupports('LOGINDISABLED')) {
|
|
err = new Error('Logging in is disabled on this server');
|
|
err.source = 'authentication';
|
|
return reentry(err);
|
|
}
|
|
|
|
if (self.serverSupports('AUTH=XOAUTH') && self._config.xoauth) {
|
|
self._caps = undefined;
|
|
self._enqueue('AUTHENTICATE XOAUTH ' + escape(self._config.xoauth),
|
|
checkCaps);
|
|
} else if (self.serverSupports('AUTH=XOAUTH2') && self._config.xoauth2) {
|
|
self._caps = undefined;
|
|
self._enqueue('AUTHENTICATE XOAUTH2 ' + escape(self._config.xoauth2),
|
|
checkCaps);
|
|
} else if (self._config.user && self._config.password) {
|
|
self._caps = undefined;
|
|
self._enqueue('LOGIN "' + escape(self._config.user) + '" "'
|
|
+ escape(self._config.password) + '"', checkCaps);
|
|
} else {
|
|
err = new Error('No supported authentication method(s) available. '
|
|
+ 'Unable to login.');
|
|
err.source = 'authentication';
|
|
return reentry(err);
|
|
}
|
|
} else
|
|
reentry();
|
|
});
|
|
};
|
|
|
|
Connection.prototype._processQueue = function() {
|
|
if (this._curReq || !this._queue.length || !this._sock.writable)
|
|
return;
|
|
|
|
this._curReq = this._queue.shift();
|
|
|
|
if (this._tagcount === MAX_INT)
|
|
this._tagcount = 0;
|
|
|
|
var prefix;
|
|
|
|
if (this._curReq.type === 'IDLE' || this._curReq.type === 'NOOP')
|
|
prefix = this._curReq.type;
|
|
else
|
|
prefix = 'A' + (this._tagcount++);
|
|
|
|
var out = prefix + ' ' + this._curReq.fullcmd;
|
|
this.debug && this.debug('=> ' + inspect(out));
|
|
this._sock.write(out + CRLF);
|
|
};
|
|
|
|
Connection.prototype._enqueue = function(fullcmd, promote, cb) {
|
|
if (typeof promote === 'function') {
|
|
cb = promote;
|
|
promote = false;
|
|
}
|
|
|
|
var info = {
|
|
type: fullcmd.match(RE_CMD)[1],
|
|
fullcmd: fullcmd,
|
|
cb: cb,
|
|
cbargs: []
|
|
}, self = this;
|
|
|
|
if (promote)
|
|
this._queue.unshift(info);
|
|
else
|
|
this._queue.push(info);
|
|
|
|
if (!this._curReq) {
|
|
// defer until next tick for requests like APPEND where access to the
|
|
// request object is needed immediately after enqueueing
|
|
process.nextTick(function() { self._processQueue(); });
|
|
} else if (this._curReq.type === 'IDLE') {
|
|
this._idle.enabled = false;
|
|
this.debug && this.debug('=> DONE');
|
|
this._sock.write('DONE' + CRLF);
|
|
}
|
|
};
|
|
|
|
Connection.parseHeader = parseHeader; // from Parser.js
|
|
|
|
module.exports = Connection;
|
|
|
|
// utilities -------------------------------------------------------------------
|
|
|
|
function escape(str) {
|
|
return str.replace(RE_BACKSLASH, '\\\\').replace(RE_DBLQUOTE, '\\"');
|
|
}
|
|
function validateUIDList(uids) {
|
|
for (var i = 0, len = uids.length, intval; i < len; ++i) {
|
|
if (typeof uids[i] === 'string') {
|
|
if (uids[i] === '*' || uids[i] === '*:*') {
|
|
if (len > 1)
|
|
uids = ['*'];
|
|
break;
|
|
} else if (RE_NUM_RANGE.test(uids[i]))
|
|
continue;
|
|
}
|
|
intval = parseInt(''+uids[i], 10);
|
|
if (isNaN(intval)) {
|
|
throw new Error('Message ID/number must be an integer, "*", or a range: '
|
|
+ uids[i]);
|
|
} else if (typeof uids[i] !== 'number')
|
|
uids[i] = intval;
|
|
}
|
|
}
|
|
function buildSearchQuery(options, extensions, isOrChild) {
|
|
var searchargs = '';
|
|
for (var i = 0, len = options.length; i < len; ++i) {
|
|
var criteria = (isOrChild ? options : options[i]),
|
|
args = null,
|
|
modifier = (isOrChild ? '' : ' ');
|
|
if (typeof criteria === 'string')
|
|
criteria = criteria.toUpperCase();
|
|
else if (Array.isArray(criteria)) {
|
|
if (criteria.length > 1)
|
|
args = criteria.slice(1);
|
|
if (criteria.length > 0)
|
|
criteria = criteria[0].toUpperCase();
|
|
} else
|
|
throw new Error('Unexpected search option data type. '
|
|
+ 'Expected string or array. Got: ' + typeof criteria);
|
|
if (criteria === 'OR') {
|
|
if (args.length !== 2)
|
|
throw new Error('OR must have exactly two arguments');
|
|
searchargs += ' OR (';
|
|
searchargs += buildSearchQuery(args[0], extensions, true);
|
|
searchargs += ') (';
|
|
searchargs += buildSearchQuery(args[1], extensions, true);
|
|
searchargs += ')';
|
|
} else {
|
|
if (criteria[0] === '!') {
|
|
modifier += 'NOT ';
|
|
criteria = criteria.substr(1);
|
|
}
|
|
switch(criteria) {
|
|
// -- Standard criteria --
|
|
case 'ALL':
|
|
case 'ANSWERED':
|
|
case 'DELETED':
|
|
case 'DRAFT':
|
|
case 'FLAGGED':
|
|
case 'NEW':
|
|
case 'SEEN':
|
|
case 'RECENT':
|
|
case 'OLD':
|
|
case 'UNANSWERED':
|
|
case 'UNDELETED':
|
|
case 'UNDRAFT':
|
|
case 'UNFLAGGED':
|
|
case 'UNSEEN':
|
|
searchargs += modifier + criteria;
|
|
break;
|
|
case 'BCC':
|
|
case 'BODY':
|
|
case 'CC':
|
|
case 'FROM':
|
|
case 'SUBJECT':
|
|
case 'TEXT':
|
|
case 'TO':
|
|
if (!args || args.length !== 1)
|
|
throw new Error('Incorrect number of arguments for search option: '
|
|
+ criteria);
|
|
searchargs += modifier + criteria + ' "' + escape(''+args[0])
|
|
+ '"';
|
|
break;
|
|
case 'BEFORE':
|
|
case 'ON':
|
|
case 'SENTBEFORE':
|
|
case 'SENTON':
|
|
case 'SENTSINCE':
|
|
case 'SINCE':
|
|
if (!args || args.length !== 1)
|
|
throw new Error('Incorrect number of arguments for search option: '
|
|
+ criteria);
|
|
else if (!(args[0] instanceof Date)) {
|
|
if ((args[0] = new Date(args[0])).toString() === 'Invalid Date')
|
|
throw new Error('Search option argument must be a Date object'
|
|
+ ' or a parseable date string');
|
|
}
|
|
searchargs += modifier + criteria + ' ' + args[0].getDate() + '-'
|
|
+ MONTHS[args[0].getMonth()] + '-'
|
|
+ args[0].getFullYear();
|
|
break;
|
|
case 'KEYWORD':
|
|
case 'UNKEYWORD':
|
|
if (!args || args.length !== 1)
|
|
throw new Error('Incorrect number of arguments for search option: '
|
|
+ criteria);
|
|
searchargs += modifier + criteria + ' ' + args[0];
|
|
break;
|
|
case 'LARGER':
|
|
case 'SMALLER':
|
|
if (!args || args.length !== 1)
|
|
throw new Error('Incorrect number of arguments for search option: '
|
|
+ criteria);
|
|
var num = parseInt(args[0], 10);
|
|
if (isNaN(num))
|
|
throw new Error('Search option argument must be a number');
|
|
searchargs += modifier + criteria + ' ' + args[0];
|
|
break;
|
|
case 'HEADER':
|
|
if (!args || args.length !== 2)
|
|
throw new Error('Incorrect number of arguments for search option: '
|
|
+ criteria);
|
|
searchargs += modifier + criteria + ' "' + escape(''+args[0])
|
|
+ '" "' + escape(''+args[1]) + '"';
|
|
break;
|
|
case 'UID':
|
|
if (!args)
|
|
throw new Error('Incorrect number of arguments for search option: '
|
|
+ criteria);
|
|
validateUIDList(args);
|
|
searchargs += modifier + criteria + ' ' + args.join(',');
|
|
break;
|
|
// -- Extensions criteria --
|
|
case 'X-GM-MSGID': // Gmail unique message ID
|
|
case 'X-GM-THRID': // Gmail thread ID
|
|
if (extensions.indexOf('X-GM-EXT-1') === -1)
|
|
throw new Error('IMAP extension not available: ' + criteria);
|
|
var val;
|
|
if (!args || args.length !== 1)
|
|
throw new Error('Incorrect number of arguments for search option: '
|
|
+ criteria);
|
|
else {
|
|
val = ''+args[0];
|
|
if (!(RE_INTEGER.test(args[0])))
|
|
throw new Error('Invalid value');
|
|
}
|
|
searchargs += modifier + criteria + ' ' + val;
|
|
break;
|
|
case 'X-GM-RAW': // Gmail search syntax
|
|
if (extensions.indexOf('X-GM-EXT-1') === -1)
|
|
throw new Error('IMAP extension not available: ' + criteria);
|
|
if (!args || args.length !== 1)
|
|
throw new Error('Incorrect number of arguments for search option: '
|
|
+ criteria);
|
|
searchargs += modifier + criteria + ' "' + escape(''+args[0])
|
|
+ '"';
|
|
break;
|
|
case 'X-GM-LABELS': // Gmail labels
|
|
if (extensions.indexOf('X-GM-EXT-1') === -1)
|
|
throw new Error('IMAP extension not available: ' + criteria);
|
|
if (!args || args.length !== 1)
|
|
throw new Error('Incorrect number of arguments for search option: '
|
|
+ criteria);
|
|
searchargs += modifier + criteria + ' ' + args[0];
|
|
break;
|
|
default:
|
|
try {
|
|
// last hope it's a seqno set
|
|
// http://tools.ietf.org/html/rfc3501#section-6.4.4
|
|
var seqnos = (args ? [criteria].concat(args) : [criteria]);
|
|
validateUIDList(seqnos);
|
|
searchargs += modifier + seqnos.join(',');
|
|
} catch(e) {
|
|
throw new Error('Unexpected search option: ' + criteria);
|
|
}
|
|
}
|
|
}
|
|
if (isOrChild)
|
|
break;
|
|
}
|
|
return searchargs;
|
|
}
|