RocketChat/Rocket.Chat

/*

    Node.js POP3 client library

    Copyright (C) 2011-2013 by Ditesh Shashikant Gathani <ditesh@gathani.org>

    Permission is hereby granted, free of charge, to any person obtaining a copy
    of this software and associated documentation files (the "Software"), to deal
    in the Software without restriction, including without limitation the rights
    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    copies of the Software, and to permit persons to whom the Software is
    furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be included in
    all copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
    THE SOFTWARE.

*/

var net = require('net'),
    tls = require('tls'),
    util = require('util'),
    crypto = require('crypto'),
    events = require('events');

// Constructor
function POP3Client(port, host, options) {
    if (options === undefined) options = {};

    // Optional constructor arguments
    var enabletls = options.enabletls !== undefined ? options.enabletls : false;
    var ignoretlserrs = options.ignoretlserrs !== undefined ? options.ignoretlserrs : false;
    var debug = options.debug || false;

    var tlsDirectOpts = options.tlsopts !== undefined ? options.tlsopts : {};

    // Private variables follow
    var self = this;
    var response = null;
    var checkResp = true;
    var bufferedData = '';
    var state = 0;
    var locked = false;
    var multiline = false;
    var socket = null;
    var tlssock = null;
    var callback = function (resp, data) {
        if (resp === false) {
            locked = false;
            callback = function () {};
            self.emit('connect', false, data);
        } else {
            // Checking for APOP support
            var banner = data.trim();
            var bannerComponents = banner.split(' ');

            for (var i = 0; i < bannerComponents.length; i++) {
                if (bannerComponents[i].indexOf('@') > 0) {
                    self.data['apop'] = true;
                    self.data['apop-timestamp'] = bannerComponents[i];
                    break;
                }
            }

            state = 1;
            self.data['banner'] = banner;
            self.emit('connect', true, data);
        }
    };

    // Public variables follow
    this.data = {
        host: host,
        port: port,
        banner: '',
        stls: false,
        apop: false,
        username: '',
        tls: enabletls,
        ignoretlserrs: ignoretlserrs,
    };

    // Privileged methods follow
    this.setCallback = function (cb) {
        callback = cb;
    };
    this.getCallback = function () {
        return callback;
    };
    this.setState = function (val) {
        state = val;
    };
    this.getState = function () {
        return state;
    };
    this.setLocked = function (val) {
        locked = val;
    };
    this.getLocked = function () {
        return locked;
    };
    this.setMultiline = function (val) {
        multiline = val;
    };
    this.getMultiline = function () {
        return multiline;
    };

    // Writes to remote server socket
    this.write = function (command, argument) {
        var text = command;

        if (argument !== undefined) text = text + ' ' + argument + '\r\n';
        else text = text + '\r\n';

        if (debug) console.log('Client: ' + util.inspect(text));

        socket.write(text);
    };

    // Kills the socket connection
    this.end = function () {
        socket.end();
    };

    // Upgrades a standard unencrypted TCP connection to use TLS
    // Liberally copied and modified from https://gist.github.com/848444
    // starttls() should be a private function, but I can't figure out
    // how to get a public prototypal method (stls) to talk to private method (starttls)
    // which references private variables without going through a privileged method
    this.starttls = function (options) {
        var s = socket;
        s.removeAllListeners('end');
        s.removeAllListeners('data');
        s.removeAllListeners('error');
        socket = null;

        var sslcontext = require('crypto').createCredentials(options);
        var pair = tls.createSecurePair(sslcontext, false);
        var cleartext = pipe(pair);

        pair.on('secure', function () {
            var verifyError = pair.ssl.verifyError();
            cleartext.authorized = true;

            if (verifyError) {
                cleartext.authorized = false;
                cleartext.authorizationError = verifyError;
            }

            cleartext.on('data', onData);
            cleartext.on('error', onError);
            cleartext.on('end', onEnd);
            socket = cleartext;
            self.getCallback()(cleartext.authorized, cleartext.authorizationError);
        });

        cleartext._controlReleased = true;

        function pipe(pair) {
            pair.encrypted.pipe(s);
            s.pipe(pair.encrypted);

            pair.fd = s.fd;
            var cleartext = pair.cleartext;
            cleartext.socket = s;
            cleartext.encrypted = pair.encrypted;
            cleartext.authorized = false;

            function onerror(e) {
                if (cleartext._controlReleased) cleartext.emit('error', e);
            }

            function onclose() {
                s.removeListener('error', onerror);
                s.removeListener('close', onclose);
            }

            s.on('error', onerror);
            s.on('close', onclose);
            return cleartext;
        }
    };

    // Private methods follow
    // Event handlers follow
    function onData(data) {
        data = data.toString('ascii');
        bufferedData += data;

        if (debug) console.log('Server: ' + util.inspect(data));

        if (checkResp === true) {
            if (bufferedData.substr(0, 3) === '+OK') {
                checkResp = false;
                response = true;
            } else if (bufferedData.substr(0, 4) === '-ERR') {
                checkResp = false;
                response = false;

                // The following is only used for SASL
            } else if (multiline === false) {
                checkResp = false;
                response = true;
            }
        }

        if (checkResp === false) {
            if (multiline === true && (response === false || bufferedData.substr(bufferedData.length - 5) === '\r\n.\r\n')) {
                // Make a copy to avoid race conditions
                var responseCopy = response;
                var bufferedDataCopy = bufferedData;

                response = null;
                checkResp = true;
                multiline = false;
                bufferedData = '';

                callback(responseCopy, bufferedDataCopy);
            } else if (multiline === false) {
                // Make a copy to avoid race conditions
                var responseCopy = response;
                var bufferedDataCopy = bufferedData;

                response = null;
                checkResp = true;
                multiline = false;
                bufferedData = '';

                callback(responseCopy, bufferedDataCopy);
            }
        }
    }

    function onError(err) {
        if (err.errno === 111) self.emit('connect', false, err);
        else self.emit('error', err);
    }

    function onEnd(data) {
        self.setState(0);
        socket = null;
    }

    function onClose() {
        self.emit('close');
    }

    // Constructor code follows
    // Set up EventEmitter constructor function
    events.EventEmitter.call(this);

    // Remote end socket
    if (enabletls === true) {
        tlssock = tls.connect(
            {
                host: host,
                port: port,
                rejectUnauthorized: !self.data.ignoretlserrs,
            },
            function () {
                if (tlssock.authorized === false && self.data['ignoretlserrs'] === false) self.emit('tls-error', tlssock.authorizationError);
            },
        );

        socket = tlssock;
    } else socket = new net.createConnection(port, host);

    // Set up event handlers
    socket.on('data', onData);
    socket.on('error', onError);
    socket.on('end', onEnd);
    socket.on('close', onClose);
}

util.inherits(POP3Client, events.EventEmitter);

POP3Client.prototype.login = function (username, password) {
    var self = this;

    if (self.getState() !== 1) self.emit('invalid-state', 'login');
    else if (self.getLocked() === true) self.emit('locked', 'login');
    else {
        self.setLocked(true);
        self.setCallback(function (resp, data) {
            if (resp === false) {
                self.setLocked(false);
                self.setCallback(function () {});
                self.emit('login', false, data);
            } else {
                self.setCallback(function (resp, data) {
                    self.setLocked(false);
                    self.setCallback(function () {});

                    if (resp !== false) self.setState(2);
                    self.emit('login', resp, data);
                });

                self.setMultiline(false);
                self.write('PASS', password);
            }
        });

        self.setMultiline(false);
        self.write('USER', username);
    }
};

// SASL AUTH implementation
// Currently supports SASL PLAIN and CRAM-MD5
POP3Client.prototype.auth = function (type, username, password) {
    type = type.toUpperCase();
    var self = this;
    var types = { 'PLAIN': 1, 'CRAM-MD5': 1 };
    var initialresp = '';

    if (self.getState() !== 1) self.emit('invalid-state', 'auth');
    else if (self.getLocked() === true) self.emit('locked', 'auth');

    if (type in types === false) {
        self.emit('auth', false, 'Invalid auth type', null);
        return;
    }

    function tlsok() {
        if (type === 'PLAIN') {
            initialresp = ' ' + new Buffer(username + '\u0000' + username + '\u0000' + password).toString('base64') + '=';
            self.setCallback(function (resp, data) {
                if (resp !== false) self.setState(2);
                self.emit('auth', resp, data, data);
            });
        } else if (type === 'CRAM-MD5') {
            self.setCallback(function (resp, data) {
                if (resp === false) self.emit('auth', resp, 'Server responded -ERR to AUTH CRAM-MD5', data);
                else {
                    var challenge = new Buffer(data.trim().substr(2), 'base64').toString();
                    var hmac = crypto.createHmac('md5', password);
                    var response = new Buffer(username + ' ' + hmac.update(challenge).digest('hex')).toString('base64');

                    self.setCallback(function (resp, data) {
                        var errmsg = null;

                        if (resp !== false) self.setState(2);
                        else errmsg = 'Server responded -ERR to response';

                        self.emit('auth', resp, null, data);
                    });

                    self.write(response);
                }
            });
        }

        self.write('AUTH ' + type + initialresp);
    }

    if (self.data['tls'] === false && self.data['stls'] === false) {
        // Remove all existing STLS listeners
        self.removeAllListeners('stls');

        self.on('stls', function (resp, rawdata) {
            if (resp === false) {
                // We (optionally) ignore self signed cert errors,
                // in blatant violation of RFC 2595, Section 2.4
                if (self.data['ignoretlserrs'] === true && rawdata === 'DEPTH_ZERO_SELF_SIGNED_CERT') tlsok();
                else self.emit('auth', false, 'Unable to upgrade connection to STLS', rawdata);
            } else tlsok();
        });

        self.stls();
    } else tlsok();
};

POP3Client.prototype.apop = function (username, password) {
    var self = this;

    if (self.getState() !== 1) self.emit('invalid-state', 'apop');
    else if (self.getLocked() === true) self.emit('locked', 'apop');
    else if (self.data['apop'] === false) self.emit('apop', false, 'APOP support not detected on remote server');
    else {
        self.setLocked(true);
        self.setCallback(function (resp, data) {
            self.setLocked(false);
            self.setCallback(function () {});

            if (resp === true) self.setState(2);
            self.emit('apop', resp, data);
        });

        self.setMultiline(false);
        self.write(
            'APOP',
            username +
                ' ' +
                crypto
                    .createHash('md5')
                    .update(self.data['apop-timestamp'] + password)
                    .digest('hex'),
        );
    }
};

POP3Client.prototype.stls = function () {
    var self = this;

    if (self.getState() !== 1) self.emit('invalid-state', 'stls');
    else if (self.getLocked() === true) self.emit('locked', 'stls');
    else if (self.data['tls'] === true) self.emit('stls', false, 'Unable to execute STLS as TLS connection already established');
    else {
        self.setLocked(true);
        self.setCallback(function (resp, data) {
            self.setLocked(false);
            self.setCallback(function () {});

            if (resp === true) {
                self.setCallback(function (resp, data) {
                    if (resp === false && self.data['ignoretlserrs'] === true && data === 'DEPTH_ZERO_SELF_SIGNED_CERT') resp = true;

                    self.data['stls'] = true;
                    self.emit('stls', resp, data);
                });

                self.starttls();
            } else self.emit('stls', false, data);
        });

        self.setMultiline(false);
        self.write('STLS');
    }
};

POP3Client.prototype.top = function (msgnumber, lines) {
    var self = this;

    if (self.getState() !== 2) self.emit('invalid-state', 'top');
    else if (self.getLocked() === true) self.emit('locked', 'top');
    else {
        self.setCallback(function (resp, data) {
            var returnValue = null;
            self.setLocked(false);
            self.setCallback(function () {});

            if (resp !== false) {
                returnValue = '';
                var startOffset = data.indexOf('\r\n', 0) + 2;
                var endOffset = data.indexOf('\r\n.\r\n', 0) + 2;

                if (endOffset > startOffset) returnValue = data.substr(startOffset, endOffset - startOffset);
            }

            self.emit('top', resp, msgnumber, returnValue, data);
        });

        self.setMultiline(true);
        self.write('TOP', msgnumber + ' ' + lines);
    }
};

POP3Client.prototype.list = function (msgnumber) {
    var self = this;

    if (self.getState() !== 2) self.emit('invalid-state', 'list');
    else if (self.getLocked() === true) self.emit('locked', 'list');
    else {
        self.setLocked(true);
        self.setCallback(function (resp, data) {
            var returnValue = null;
            var msgcount = 0;
            self.setLocked(false);
            self.setCallback(function () {});

            if (resp !== false) {
                returnValue = [];

                if (msgnumber !== undefined) {
                    msgcount = 1;
                    listitem = data.split(' ');
                    returnValue[listitem[1]] = listitem[2];
                } else {
                    var offset = 0;
                    var listitem = '';
                    var newoffset = 0;
                    var returnValue = [];
                    var startOffset = data.indexOf('\r\n', 0) + 2;
                    var endOffset = data.indexOf('\r\n.\r\n', 0) + 2;

                    if (endOffset > startOffset) {
                        data = data.substr(startOffset, endOffset - startOffset);

                        while (true) {
                            if (offset > endOffset) break;

                            newoffset = data.indexOf('\r\n', offset);

                            if (newoffset < 0) break;

                            msgcount++;
                            listitem = data.substr(offset, newoffset - offset);
                            listitem = listitem.split(' ');
                            returnValue[listitem[0]] = listitem[1];
                            offset = newoffset + 2;
                        }
                    }
                }
            }

            self.emit('list', resp, msgcount, msgnumber, returnValue, data);
        });

        if (msgnumber !== undefined) self.setMultiline(false);
        else self.setMultiline(true);

        self.write('LIST', msgnumber);
    }
};

POP3Client.prototype.stat = function () {
    var self = this;

    if (self.getState() !== 2) self.emit('invalid-state', 'stat');
    else if (self.getLocked() === true) self.emit('locked', 'stat');
    else {
        self.setLocked(true);
        self.setCallback(function (resp, data) {
            var returnValue = null;
            self.setLocked(false);
            self.setCallback(function () {});

            if (resp !== false) {
                listitem = data.split(' ');
                returnValue = {
                    count: listitem[1].trim(),
                    octets: listitem[2].trim(),
                };
            }

            self.emit('stat', resp, returnValue, data);
        });

        self.setMultiline(false);
        self.write('STAT', undefined);
    }
};

POP3Client.prototype.uidl = function (msgnumber) {
    var self = this;

    if (self.getState() !== 2) self.emit('invalid-state', 'uidl');
    else if (self.getLocked() === true) self.emit('locked', 'uidl');
    else {
        self.setLocked(true);
        self.setCallback(function (resp, data) {
            var returnValue = null;
            self.setLocked(false);
            self.setCallback(function () {});

            if (resp !== false) {
                returnValue = [];

                if (msgnumber !== undefined) {
                    listitem = data.split(' ');
                    returnValue[listitem[1]] = listitem[2].trim();
                } else {
                    var offset = 0;
                    var listitem = '';
                    var newoffset = 0;
                    var returnValue = [];
                    var startOffset = data.indexOf('\r\n', 0) + 2;
                    var endOffset = data.indexOf('\r\n.\r\n', 0) + 2;

                    if (endOffset > startOffset) {
                        data = data.substr(startOffset, endOffset - startOffset);
                        endOffset -= startOffset;

                        while (offset < endOffset) {
                            newoffset = data.indexOf('\r\n', offset);
                            listitem = data.substr(offset, newoffset - offset);
                            listitem = listitem.split(' ');
                            returnValue[listitem[0]] = listitem[1];
                            offset = newoffset + 2;
                        }
                    }
                }
            }

            self.emit('uidl', resp, msgnumber, returnValue, data);
        });

        if (msgnumber !== undefined) self.setMultiline(false);
        else self.setMultiline(true);

        self.write('UIDL', msgnumber);
    }
};

POP3Client.prototype.retr = function (msgnumber) {
    var self = this;

    if (self.getState() !== 2) self.emit('invalid-state', 'retr');
    else if (self.getLocked() === true) self.emit('locked', 'retr');
    else {
        self.setLocked(true);
        self.setCallback(function (resp, data) {
            var returnValue = null;
            self.setLocked(false);
            self.setCallback(function () {});

            if (resp !== false) {
                var startOffset = data.indexOf('\r\n', 0) + 2;
                var endOffset = data.indexOf('\r\n.\r\n', 0);
                returnValue = data.substr(startOffset, endOffset - startOffset);
            }

            self.emit('retr', resp, msgnumber, returnValue, data);
        });

        self.setMultiline(true);
        self.write('RETR', msgnumber);
    }
};

POP3Client.prototype.dele = function (msgnumber) {
    var self = this;

    if (self.getState() !== 2) self.emit('invalid-state', 'dele');
    else if (self.getLocked() === true) self.emit('locked', 'dele');
    else {
        self.setLocked(true);
        self.setCallback(function (resp, data) {
            self.setLocked(false);
            self.setCallback(function () {});
            self.emit('dele', resp, msgnumber, data);
        });

        self.setMultiline(false);
        self.write('DELE', msgnumber);
    }
};

POP3Client.prototype.noop = function () {
    var self = this;

    if (self.getState() !== 2) self.emit('invalid-state', 'noop');
    else if (self.getLocked() === true) self.emit('locked', 'noop');
    else {
        self.setLocked(true);
        self.setCallback(function (resp, data) {
            self.setLocked(false);
            self.setCallback(function () {});
            self.emit('noop', resp, data);
        });

        self.setMultiline(false);
        self.write('NOOP', undefined);
    }
};

POP3Client.prototype.rset = function () {
    var self = this;

    if (self.getState() !== 2) self.emit('invalid-state', 'rset');
    else if (self.getLocked() === true) self.emit('locked', 'rset');
    else {
        self.setLocked(true);
        self.setCallback(function (resp, data) {
            self.setLocked(false);
            self.setCallback(function () {});
            self.emit('rset', resp, data);
        });

        self.setMultiline(false);
        self.write('RSET', undefined);
    }
};

POP3Client.prototype.capa = function () {
    var self = this;

    if (self.getState() === 0) self.emit('invalid-state', 'quit');
    else if (self.getLocked() === true) self.emit('locked', 'capa');
    else {
        self.setLocked(true);
        self.setCallback(function (resp, data) {
            var returnValue = null;
            self.setLocked(false);
            self.setCallback(function () {});

            if (resp === true) {
                var startOffset = data.indexOf('\r\n', 0) + 2;
                var endOffset = data.indexOf('\r\n.\r\n', 0);
                returnValue = data.substr(startOffset, endOffset - startOffset);
                returnValue = returnValue.split('\r\n');
            }

            self.emit('capa', resp, returnValue, data);
        });

        self.setMultiline(true);
        self.write('CAPA', undefined);
    }
};

POP3Client.prototype.quit = function () {
    var self = this;

    if (self.getState() === 0) self.emit('invalid-state', 'quit');
    else if (self.getLocked() === true) self.emit('locked', 'quit');
    else {
        self.setLocked(true);
        self.setCallback(function (resp, data) {
            self.setLocked(false);
            self.setCallback(function () {});

            self.end();
            self.emit('quit', resp, data);
        });

        self.setMultiline(false);
        self.write('QUIT', undefined);
    }
};

module.exports = POP3Client;