'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); /* eslint-disable camelcase */

var _emailjsBase = require('emailjs-base64');

var _emailjsTcpSocket = require('emailjs-tcp-socket');

var _emailjsTcpSocket2 = _interopRequireDefault(_emailjsTcpSocket);

var _textEncoding = require('text-encoding');

var _parser = require('./parser');

var _parser2 = _interopRequireDefault(_parser);

var _logger = require('./logger');

var _logger2 = _interopRequireDefault(_logger);

var _common = require('./common');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var DEBUG_TAG = 'SMTP Client';

/**
 * Lower Bound for socket timeout to wait since the last data was written to a socket
 */
var TIMEOUT_SOCKET_LOWER_BOUND = 10000;

/**
 * Multiplier for socket timeout:
 *
 * We assume at least a GPRS connection with 115 kb/s = 14,375 kB/s tops, so 10 KB/s to be on
 * the safe side. We can timeout after a lower bound of 10s + (n KB / 10 KB/s). A 1 MB message
 * upload would be 110 seconds to wait for the timeout. 10 KB/s === 0.1 s/B
 */
var TIMEOUT_SOCKET_MULTIPLIER = 0.1;

var SmtpClient = function () {
  /**
   * Creates a connection object to a SMTP server and allows to send mail through it.
   * Call `connect` method to inititate the actual connection, the constructor only
   * defines the properties but does not actually connect.
   *
   * NB! The parameter order (host, port) differs from node.js "way" (port, host)
   *
   * @constructor
   *
   * @param {String} [host="localhost"] Hostname to conenct to
   * @param {Number} [port=25] Port number to connect to
   * @param {Object} [options] Optional options object
   * @param {Boolean} [options.useSecureTransport] Set to true, to use encrypted connection
   * @param {String} [options.name] Client hostname for introducing itself to the server
   * @param {Object} [options.auth] Authentication options. Depends on the preferred authentication method. Usually {user, pass}
   * @param {String} [options.authMethod] Force specific authentication method
   * @param {Boolean} [options.disableEscaping] If set to true, do not escape dots on the beginning of the lines
   */
  function SmtpClient(host, port) {
    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

    _classCallCheck(this, SmtpClient);

    this.options = options;

    this.timeoutSocketLowerBound = TIMEOUT_SOCKET_LOWER_BOUND;
    this.timeoutSocketMultiplier = TIMEOUT_SOCKET_MULTIPLIER;

    this.port = port || (this.options.useSecureTransport ? 465 : 25);
    this.host = host || 'localhost';

    /**
     * If set to true, start an encrypted connection instead of the plaintext one
     * (recommended if applicable). If useSecureTransport is not set but the port used is 465,
     * then ecryption is used by default.
     */
    this.options.useSecureTransport = 'useSecureTransport' in this.options ? !!this.options.useSecureTransport : this.port === 465;

    this.options.auth = this.options.auth || false; // Authentication object. If not set, authentication step will be skipped.
    this.options.name = this.options.name || 'localhost'; // Hostname of the client, this will be used for introducing to the server
    this.socket = false; // Downstream TCP socket to the SMTP server, created with mozTCPSocket
    this.destroyed = false; // Indicates if the connection has been closed and can't be used anymore
    this.waitDrain = false; // Keeps track if the downstream socket is currently full and a drain event should be waited for or not

    // Private properties

    this._parser = new _parser2.default(); // SMTP response parser object. All data coming from the downstream server is feeded to this parser
    this._authenticatedAs = null; // If authenticated successfully, stores the username
    this._supportedAuth = []; // A list of authentication mechanisms detected from the EHLO response and which are compatible with this library
    this._dataMode = false; // If true, accepts data from the upstream to be passed directly to the downstream socket. Used after the DATA command
    this._lastDataBytes = ''; // Keep track of the last bytes to see how the terminating dot should be placed
    this._envelope = null; // Envelope object for tracking who is sending mail to whom
    this._currentAction = null; // Stores the function that should be run after a response has been received from the server
    this._secureMode = !!this.options.useSecureTransport; // Indicates if the connection is secured or plaintext
    this._socketTimeoutTimer = false; // Timer waiting to declare the socket dead starting from the last write
    this._socketTimeoutStart = false; // Start time of sending the first packet in data mode
    this._socketTimeoutPeriod = false; // Timeout for sending in data mode, gets extended with every send()

    // Activate logging
    this.createLogger();

    // Event placeholders
    this.onerror = function (e) {}; // Will be run when an error occurs. The `onclose` event will fire subsequently.
    this.ondrain = function () {}; // More data can be buffered in the socket.
    this.onclose = function () {}; // The connection to the server has been closed
    this.onidle = function () {}; // The connection is established and idle, you can send mail now
    this.onready = function (failedRecipients) {}; // Waiting for mail body, lists addresses that were not accepted as recipients
    this.ondone = function (success) {}; // The mail has been sent. Wait for `onidle` next. Indicates if the message was queued by the server.
  }

  /**
   * Initiate a connection to the server
   */


  _createClass(SmtpClient, [{
    key: 'connect',
    value: function connect() {
      var SocketContructor = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _emailjsTcpSocket2.default;

      this.socket = SocketContructor.open(this.host, this.port, {
        binaryType: 'arraybuffer',
        useSecureTransport: this._secureMode,
        ca: this.options.ca,
        tlsWorkerPath: this.options.tlsWorkerPath,
        ws: this.options.ws
      });

      // allows certificate handling for platform w/o native tls support
      // oncert is non standard so setting it might throw if the socket object is immutable
      try {
        this.socket.oncert = this.oncert;
      } catch (E) {}
      this.socket.onerror = this._onError.bind(this);
      this.socket.onopen = this._onOpen.bind(this);
    }

    /**
     * Pauses `data` events from the downstream SMTP server
     */

  }, {
    key: 'suspend',
    value: function suspend() {
      if (this.socket && this.socket.readyState === 'open') {
        this.socket.suspend();
      }
    }

    /**
     * Resumes `data` events from the downstream SMTP server. Be careful of not
     * resuming something that is not suspended - an error is thrown in this case
     */

  }, {
    key: 'resume',
    value: function resume() {
      if (this.socket && this.socket.readyState === 'open') {
        this.socket.resume();
      }
    }

    /**
     * Sends QUIT
     */

  }, {
    key: 'quit',
    value: function quit() {
      this.logger.debug(DEBUG_TAG, 'Sending QUIT...');
      this._sendCommand('QUIT');
      this._currentAction = this.close;
    }

    /**
     * Reset authentication
     *
     * @param {Object} [auth] Use this if you want to authenticate as another user
     */

  }, {
    key: 'reset',
    value: function reset(auth) {
      this.options.auth = auth || this.options.auth;
      this.logger.debug(DEBUG_TAG, 'Sending RSET...');
      this._sendCommand('RSET');
      this._currentAction = this._actionRSET;
    }

    /**
     * Closes the connection to the server
     */

  }, {
    key: 'close',
    value: function close() {
      this.logger.debug(DEBUG_TAG, 'Closing connection...');
      if (this.socket && this.socket.readyState === 'open') {
        this.socket.close();
      } else {
        this._destroy();
      }
    }

    // Mail related methods

    /**
     * Initiates a new message by submitting envelope data, starting with
     * `MAIL FROM:` command. Use after `onidle` event
     *
     * @param {Object} envelope Envelope object in the form of {from:"...", to:["..."]}
     */

  }, {
    key: 'useEnvelope',
    value: function useEnvelope(envelope) {
      this._envelope = envelope || {};
      this._envelope.from = [].concat(this._envelope.from || 'anonymous@' + this.options.name)[0];
      this._envelope.to = [].concat(this._envelope.to || []);

      // clone the recipients array for latter manipulation
      this._envelope.rcptQueue = [].concat(this._envelope.to);
      this._envelope.rcptFailed = [];
      this._envelope.responseQueue = [];

      this._currentAction = this._actionMAIL;
      this.logger.debug(DEBUG_TAG, 'Sending MAIL FROM...');
      this._sendCommand('MAIL FROM:<' + this._envelope.from + '>');
    }

    /**
     * Send ASCII data to the server. Works only in data mode (after `onready` event), ignored
     * otherwise
     *
     * @param {String} chunk ASCII string (quoted-printable, base64 etc.) to be sent to the server
     * @return {Boolean} If true, it is safe to send more data, if false, you *should* wait for the ondrain event before sending more
     */

  }, {
    key: 'send',
    value: function send(chunk) {
      // works only in data mode
      if (!this._dataMode) {
        // this line should never be reached but if it does,
        // act like everything's normal.
        return true;
      }

      // TODO: if the chunk is an arraybuffer, use a separate function to send the data
      return this._sendString(chunk);
    }

    /**
     * Indicates that a data stream for the socket is ended. Works only in data
     * mode (after `onready` event), ignored otherwise. Use it when you are done
     * with sending the mail. This method does not close the socket. Once the mail
     * has been queued by the server, `ondone` and `onidle` are emitted.
     *
     * @param {Buffer} [chunk] Chunk of data to be sent to the server
     */

  }, {
    key: 'end',
    value: function end(chunk) {
      // works only in data mode
      if (!this._dataMode) {
        // this line should never be reached but if it does,
        // act like everything's normal.
        return true;
      }

      if (chunk && chunk.length) {
        this.send(chunk);
      }

      // redirect output from the server to _actionStream
      this._currentAction = this._actionStream;

      // indicate that the stream has ended by sending a single dot on its own line
      // if the client already closed the data with \r\n no need to do it again
      if (this._lastDataBytes === '\r\n') {
        this.waitDrain = this._send(new Uint8Array([0x2E, 0x0D, 0x0A]).buffer); // .\r\n
      } else if (this._lastDataBytes.substr(-1) === '\r') {
        this.waitDrain = this._send(new Uint8Array([0x0A, 0x2E, 0x0D, 0x0A]).buffer); // \n.\r\n
      } else {
        this.waitDrain = this._send(new Uint8Array([0x0D, 0x0A, 0x2E, 0x0D, 0x0A]).buffer); // \r\n.\r\n
      }

      // end data mode, reset the variables for extending the timeout in data mode
      this._dataMode = false;
      this._socketTimeoutStart = false;
      this._socketTimeoutPeriod = false;

      return this.waitDrain;
    }

    // PRIVATE METHODS

    // EVENT HANDLERS FOR THE SOCKET

    /**
     * Connection listener that is run when the connection to the server is opened.
     * Sets up different event handlers for the opened socket
     *
     * @event
     * @param {Event} evt Event object. Not used
     */

  }, {
    key: '_onOpen',
    value: function _onOpen(event) {
      if (event && event.data && event.data.proxyHostname) {
        this.options.name = event.data.proxyHostname;
      }

      this.socket.ondata = this._onData.bind(this);

      this.socket.onclose = this._onClose.bind(this);
      this.socket.ondrain = this._onDrain.bind(this);

      this._parser.ondata = this._onCommand.bind(this);

      this._currentAction = this._actionGreeting;
    }

    /**
     * Data listener for chunks of data emitted by the server
     *
     * @event
     * @param {Event} evt Event object. See `evt.data` for the chunk received
     */

  }, {
    key: '_onData',
    value: function _onData(evt) {
      clearTimeout(this._socketTimeoutTimer);
      var stringPayload = new _textEncoding.TextDecoder('UTF-8').decode(new Uint8Array(evt.data));
      this.logger.debug(DEBUG_TAG, 'SERVER: ' + stringPayload);
      this._parser.send(stringPayload);
    }

    /**
     * More data can be buffered in the socket, `waitDrain` is reset to false
     *
     * @event
     * @param {Event} evt Event object. Not used
     */

  }, {
    key: '_onDrain',
    value: function _onDrain() {
      this.waitDrain = false;
      this.ondrain();
    }

    /**
     * Error handler for the socket
     *
     * @event
     * @param {Event} evt Event object. See evt.data for the error
     */

  }, {
    key: '_onError',
    value: function _onError(evt) {
      if (evt instanceof Error && evt.message) {
        this.logger.error(DEBUG_TAG, evt);
        this.onerror(evt);
      } else if (evt && evt.data instanceof Error) {
        this.logger.error(DEBUG_TAG, evt.data);
        this.onerror(evt.data);
      } else {
        this.logger.error(DEBUG_TAG, new Error(evt && evt.data && evt.data.message || evt.data || evt || 'Error'));
        this.onerror(new Error(evt && evt.data && evt.data.message || evt.data || evt || 'Error'));
      }

      this.close();
    }

    /**
     * Indicates that the socket has been closed
     *
     * @event
     * @param {Event} evt Event object. Not used
     */

  }, {
    key: '_onClose',
    value: function _onClose() {
      this.logger.debug(DEBUG_TAG, 'Socket closed.');
      this._destroy();
    }

    /**
     * This is not a socket data handler but the handler for data emitted by the parser,
     * so this data is safe to use as it is always complete (server might send partial chunks)
     *
     * @event
     * @param {Object} command Parsed data
     */

  }, {
    key: '_onCommand',
    value: function _onCommand(command) {
      if (typeof this._currentAction === 'function') {
        this._currentAction(command);
      }
    }
  }, {
    key: '_onTimeout',
    value: function _onTimeout() {
      // inform about the timeout and shut down
      var error = new Error('Socket timed out!');
      this._onError(error);
    }

    /**
     * Ensures that the connection is closed and such
     */

  }, {
    key: '_destroy',
    value: function _destroy() {
      clearTimeout(this._socketTimeoutTimer);

      if (!this.destroyed) {
        this.destroyed = true;
        this.onclose();
      }
    }

    /**
     * Sends a string to the socket.
     *
     * @param {String} chunk ASCII string (quoted-printable, base64 etc.) to be sent to the server
     * @return {Boolean} If true, it is safe to send more data, if false, you *should* wait for the ondrain event before sending more
     */

  }, {
    key: '_sendString',
    value: function _sendString(chunk) {
      // escape dots
      if (!this.options.disableEscaping) {
        chunk = chunk.replace(/\n\./g, '\n..');
        if ((this._lastDataBytes.substr(-1) === '\n' || !this._lastDataBytes) && chunk.charAt(0) === '.') {
          chunk = '.' + chunk;
        }
      }

      // Keeping eye on the last bytes sent, to see if there is a <CR><LF> sequence
      // at the end which is needed to end the data stream
      if (chunk.length > 2) {
        this._lastDataBytes = chunk.substr(-2);
      } else if (chunk.length === 1) {
        this._lastDataBytes = this._lastDataBytes.substr(-1) + chunk;
      }

      this.logger.debug(DEBUG_TAG, 'Sending ' + chunk.length + ' bytes of payload');

      // pass the chunk to the socket
      this.waitDrain = this._send(new _textEncoding.TextEncoder('UTF-8').encode(chunk).buffer);
      return this.waitDrain;
    }

    /**
     * Send a string command to the server, also append \r\n if needed
     *
     * @param {String} str String to be sent to the server
     */

  }, {
    key: '_sendCommand',
    value: function _sendCommand(str) {
      this.waitDrain = this._send(new _textEncoding.TextEncoder('UTF-8').encode(str + (str.substr(-2) !== '\r\n' ? '\r\n' : '')).buffer);
    }
  }, {
    key: '_send',
    value: function _send(buffer) {
      this._setTimeout(buffer.byteLength);
      return this.socket.send(buffer);
    }
  }, {
    key: '_setTimeout',
    value: function _setTimeout(byteLength) {
      var prolongPeriod = Math.floor(byteLength * this.timeoutSocketMultiplier);
      var timeout;

      if (this._dataMode) {
        // we're in data mode, so we count only one timeout that get extended for every send().
        var now = Date.now();

        // the old timeout start time
        this._socketTimeoutStart = this._socketTimeoutStart || now;

        // the old timeout period, normalized to a minimum of TIMEOUT_SOCKET_LOWER_BOUND
        this._socketTimeoutPeriod = (this._socketTimeoutPeriod || this.timeoutSocketLowerBound) + prolongPeriod;

        // the new timeout is the delta between the new firing time (= timeout period + timeout start time) and now
        timeout = this._socketTimeoutStart + this._socketTimeoutPeriod - now;
      } else {
        // set new timout
        timeout = this.timeoutSocketLowerBound + prolongPeriod;
      }

      clearTimeout(this._socketTimeoutTimer); // clear pending timeouts
      this._socketTimeoutTimer = setTimeout(this._onTimeout.bind(this), timeout); // arm the next timeout
    }

    /**
     * Intitiate authentication sequence if needed
     */

  }, {
    key: '_authenticateUser',
    value: function _authenticateUser() {
      if (!this.options.auth) {
        // no need to authenticate, at least no data given
        this._currentAction = this._actionIdle;
        this.onidle(); // ready to take orders
        return;
      }

      var auth;

      if (!this.options.authMethod && this.options.auth.xoauth2) {
        this.options.authMethod = 'XOAUTH2';
      }

      if (this.options.authMethod) {
        auth = this.options.authMethod.toUpperCase().trim();
      } else {
        // use first supported
        auth = (this._supportedAuth[0] || 'PLAIN').toUpperCase().trim();
      }

      switch (auth) {
        case 'LOGIN':
          // LOGIN is a 3 step authentication process
          // C: AUTH LOGIN
          // C: BASE64(USER)
          // C: BASE64(PASS)
          this.logger.debug(DEBUG_TAG, 'Authentication via AUTH LOGIN');
          this._currentAction = this._actionAUTH_LOGIN_USER;
          this._sendCommand('AUTH LOGIN');
          return;
        case 'PLAIN':
          // AUTH PLAIN is a 1 step authentication process
          // C: AUTH PLAIN BASE64(\0 USER \0 PASS)
          this.logger.debug(DEBUG_TAG, 'Authentication via AUTH PLAIN');
          this._currentAction = this._actionAUTHComplete;
          this._sendCommand(
          // convert to BASE64
          'AUTH PLAIN ' + (0, _emailjsBase.encode)(
          // this.options.auth.user+'\u0000'+
          '\0' + // skip authorization identity as it causes problems with some servers
          this.options.auth.user + '\0' + this.options.auth.pass));
          return;
        case 'XOAUTH2':
          // See https://developers.google.com/gmail/xoauth2_protocol#smtp_protocol_exchange
          this.logger.debug(DEBUG_TAG, 'Authentication via AUTH XOAUTH2');
          this._currentAction = this._actionAUTH_XOAUTH2;
          this._sendCommand('AUTH XOAUTH2 ' + this._buildXOAuth2Token(this.options.auth.user, this.options.auth.xoauth2));
          return;
      }

      this._onError(new Error('Unknown authentication method ' + auth));
    }

    // ACTIONS FOR RESPONSES FROM THE SMTP SERVER

    /**
     * Initial response from the server, must have a status 220
     *
     * @param {Object} command Parsed command from the server {statusCode, data, line}
     */

  }, {
    key: '_actionGreeting',
    value: function _actionGreeting(command) {
      if (command.statusCode !== 220) {
        this._onError(new Error('Invalid greeting: ' + command.data));
        return;
      }

      if (this.options.lmtp) {
        this.logger.debug(DEBUG_TAG, 'Sending LHLO ' + this.options.name);

        this._currentAction = this._actionLHLO;
        this._sendCommand('LHLO ' + this.options.name);
      } else {
        this.logger.debug(DEBUG_TAG, 'Sending EHLO ' + this.options.name);

        this._currentAction = this._actionEHLO;
        this._sendCommand('EHLO ' + this.options.name);
      }
    }

    /**
     * Response to LHLO
     *
     * @param {Object} command Parsed command from the server {statusCode, data, line}
     */

  }, {
    key: '_actionLHLO',
    value: function _actionLHLO(command) {
      if (!command.success) {
        this.logger.error(DEBUG_TAG, 'LHLO not successful');
        this._onError(new Error(command.data));
        return;
      }

      // Process as EHLO response
      this._actionEHLO(command);
    }

    /**
     * Response to EHLO. If the response is an error, try HELO instead
     *
     * @param {Object} command Parsed command from the server {statusCode, data, line}
     */

  }, {
    key: '_actionEHLO',
    value: function _actionEHLO(command) {
      var match;

      if (!command.success) {
        if (!this._secureMode && this.options.requireTLS) {
          var errMsg = 'STARTTLS not supported without EHLO';
          this.logger.error(DEBUG_TAG, errMsg);
          this._onError(new Error(errMsg));
          return;
        }

        // Try HELO instead
        this.logger.warn(DEBUG_TAG, 'EHLO not successful, trying HELO ' + this.options.name);
        this._currentAction = this._actionHELO;
        this._sendCommand('HELO ' + this.options.name);
        return;
      }

      // Detect if the server supports PLAIN auth
      if (command.line.match(/AUTH(?:\s+[^\n]*\s+|\s+)PLAIN/i)) {
        this.logger.debug(DEBUG_TAG, 'Server supports AUTH PLAIN');
        this._supportedAuth.push('PLAIN');
      }

      // Detect if the server supports LOGIN auth
      if (command.line.match(/AUTH(?:\s+[^\n]*\s+|\s+)LOGIN/i)) {
        this.logger.debug(DEBUG_TAG, 'Server supports AUTH LOGIN');
        this._supportedAuth.push('LOGIN');
      }

      // Detect if the server supports XOAUTH2 auth
      if (command.line.match(/AUTH(?:\s+[^\n]*\s+|\s+)XOAUTH2/i)) {
        this.logger.debug(DEBUG_TAG, 'Server supports AUTH XOAUTH2');
        this._supportedAuth.push('XOAUTH2');
      }

      // Detect maximum allowed message size
      if ((match = command.line.match(/SIZE (\d+)/i)) && Number(match[1])) {
        var maxAllowedSize = Number(match[1]);
        this.logger.debug(DEBUG_TAG, 'Maximum allowd message size: ' + maxAllowedSize);
      }

      // Detect if the server supports STARTTLS
      if (!this._secureMode) {
        if (command.line.match(/[ -]STARTTLS\s?$/mi) && !this.options.ignoreTLS || !!this.options.requireTLS) {
          this._currentAction = this._actionSTARTTLS;
          this.logger.debug(DEBUG_TAG, 'Sending STARTTLS');
          this._sendCommand('STARTTLS');
          return;
        }
      }

      this._authenticateUser();
    }

    /**
     * Handles server response for STARTTLS command. If there's an error
     * try HELO instead, otherwise initiate TLS upgrade. If the upgrade
     * succeedes restart the EHLO
     *
     * @param {String} str Message from the server
     */

  }, {
    key: '_actionSTARTTLS',
    value: function _actionSTARTTLS(command) {
      if (!command.success) {
        this.logger.error(DEBUG_TAG, 'STARTTLS not successful');
        this._onError(new Error(command.data));
        return;
      }

      this._secureMode = true;
      this.socket.upgradeToSecure();

      // restart protocol flow
      this._currentAction = this._actionEHLO;
      this._sendCommand('EHLO ' + this.options.name);
    }

    /**
     * Response to HELO
     *
     * @param {Object} command Parsed command from the server {statusCode, data, line}
     */

  }, {
    key: '_actionHELO',
    value: function _actionHELO(command) {
      if (!command.success) {
        this.logger.error(DEBUG_TAG, 'HELO not successful');
        this._onError(new Error(command.data));
        return;
      }
      this._authenticateUser();
    }

    /**
     * Response to AUTH LOGIN, if successful expects base64 encoded username
     *
     * @param {Object} command Parsed command from the server {statusCode, data, line}
     */

  }, {
    key: '_actionAUTH_LOGIN_USER',
    value: function _actionAUTH_LOGIN_USER(command) {
      if (command.statusCode !== 334 || command.data !== 'VXNlcm5hbWU6') {
        this.logger.error(DEBUG_TAG, 'AUTH LOGIN USER not successful: ' + command.data);
        this._onError(new Error('Invalid login sequence while waiting for "334 VXNlcm5hbWU6 ": ' + command.data));
        return;
      }
      this.logger.debug(DEBUG_TAG, 'AUTH LOGIN USER successful');
      this._currentAction = this._actionAUTH_LOGIN_PASS;
      this._sendCommand((0, _emailjsBase.encode)(this.options.auth.user));
    }

    /**
     * Response to AUTH LOGIN username, if successful expects base64 encoded password
     *
     * @param {Object} command Parsed command from the server {statusCode, data, line}
     */

  }, {
    key: '_actionAUTH_LOGIN_PASS',
    value: function _actionAUTH_LOGIN_PASS(command) {
      if (command.statusCode !== 334 || command.data !== 'UGFzc3dvcmQ6') {
        this.logger.error(DEBUG_TAG, 'AUTH LOGIN PASS not successful: ' + command.data);
        this._onError(new Error('Invalid login sequence while waiting for "334 UGFzc3dvcmQ6 ": ' + command.data));
        return;
      }
      this.logger.debug(DEBUG_TAG, 'AUTH LOGIN PASS successful');
      this._currentAction = this._actionAUTHComplete;
      this._sendCommand((0, _emailjsBase.encode)(this.options.auth.pass));
    }

    /**
     * Response to AUTH XOAUTH2 token, if error occurs send empty response
     *
     * @param {Object} command Parsed command from the server {statusCode, data, line}
     */

  }, {
    key: '_actionAUTH_XOAUTH2',
    value: function _actionAUTH_XOAUTH2(command) {
      if (!command.success) {
        this.logger.warn(DEBUG_TAG, 'Error during AUTH XOAUTH2, sending empty response');
        this._sendCommand('');
        this._currentAction = this._actionAUTHComplete;
      } else {
        this._actionAUTHComplete(command);
      }
    }

    /**
     * Checks if authentication succeeded or not. If successfully authenticated
     * emit `idle` to indicate that an e-mail can be sent using this connection
     *
     * @param {Object} command Parsed command from the server {statusCode, data, line}
     */

  }, {
    key: '_actionAUTHComplete',
    value: function _actionAUTHComplete(command) {
      if (!command.success) {
        this.logger.debug(DEBUG_TAG, 'Authentication failed: ' + command.data);
        this._onError(new Error(command.data));
        return;
      }

      this.logger.debug(DEBUG_TAG, 'Authentication successful.');

      this._authenticatedAs = this.options.auth.user;

      this._currentAction = this._actionIdle;
      this.onidle(); // ready to take orders
    }

    /**
     * Used when the connection is idle and the server emits timeout
     *
     * @param {Object} command Parsed command from the server {statusCode, data, line}
     */

  }, {
    key: '_actionIdle',
    value: function _actionIdle(command) {
      if (command.statusCode > 300) {
        this._onError(new Error(command.line));
        return;
      }

      this._onError(new Error(command.data));
    }

    /**
     * Response to MAIL FROM command. Proceed to defining RCPT TO list if successful
     *
     * @param {Object} command Parsed command from the server {statusCode, data, line}
     */

  }, {
    key: '_actionMAIL',
    value: function _actionMAIL(command) {
      if (!command.success) {
        this.logger.debug(DEBUG_TAG, 'MAIL FROM unsuccessful: ' + command.data);
        this._onError(new Error(command.data));
        return;
      }

      if (!this._envelope.rcptQueue.length) {
        this._onError(new Error('Can\'t send mail - no recipients defined'));
      } else {
        this.logger.debug(DEBUG_TAG, 'MAIL FROM successful, proceeding with ' + this._envelope.rcptQueue.length + ' recipients');
        this.logger.debug(DEBUG_TAG, 'Adding recipient...');
        this._envelope.curRecipient = this._envelope.rcptQueue.shift();
        this._currentAction = this._actionRCPT;
        this._sendCommand('RCPT TO:<' + this._envelope.curRecipient + '>');
      }
    }

    /**
     * Response to a RCPT TO command. If the command is unsuccessful, try the next one,
     * as this might be related only to the current recipient, not a global error, so
     * the following recipients might still be valid
     *
     * @param {Object} command Parsed command from the server {statusCode, data, line}
     */

  }, {
    key: '_actionRCPT',
    value: function _actionRCPT(command) {
      if (!command.success) {
        this.logger.warn(DEBUG_TAG, 'RCPT TO failed for: ' + this._envelope.curRecipient);
        // this is a soft error
        this._envelope.rcptFailed.push(this._envelope.curRecipient);
      } else {
        this._envelope.responseQueue.push(this._envelope.curRecipient);
      }

      if (!this._envelope.rcptQueue.length) {
        if (this._envelope.rcptFailed.length < this._envelope.to.length) {
          this._currentAction = this._actionDATA;
          this.logger.debug(DEBUG_TAG, 'RCPT TO done, proceeding with payload');
          this._sendCommand('DATA');
        } else {
          this._onError(new Error('Can\'t send mail - all recipients were rejected'));
          this._currentAction = this._actionIdle;
        }
      } else {
        this.logger.debug(DEBUG_TAG, 'Adding recipient...');
        this._envelope.curRecipient = this._envelope.rcptQueue.shift();
        this._currentAction = this._actionRCPT;
        this._sendCommand('RCPT TO:<' + this._envelope.curRecipient + '>');
      }
    }

    /**
     * Response to the RSET command. If successful, clear the current authentication
     * information and reauthenticate.
     *
     * @param {Object} command Parsed command from the server {statusCode, data, line}
     */

  }, {
    key: '_actionRSET',
    value: function _actionRSET(command) {
      if (!command.success) {
        this.logger.error(DEBUG_TAG, 'RSET unsuccessful ' + command.data);
        this._onError(new Error(command.data));
        return;
      }

      this._authenticatedAs = null;
      this._authenticateUser();
    }

    /**
     * Response to the DATA command. Server is now waiting for a message, so emit `onready`
     *
     * @param {Object} command Parsed command from the server {statusCode, data, line}
     */

  }, {
    key: '_actionDATA',
    value: function _actionDATA(command) {
      // response should be 354 but according to this issue https://github.com/eleith/emailjs/issues/24
      // some servers might use 250 instead
      if ([250, 354].indexOf(command.statusCode) < 0) {
        this.logger.error(DEBUG_TAG, 'DATA unsuccessful ' + command.data);
        this._onError(new Error(command.data));
        return;
      }

      this._dataMode = true;
      this._currentAction = this._actionIdle;
      this.onready(this._envelope.rcptFailed);
    }

    /**
     * Response from the server, once the message stream has ended with <CR><LF>.<CR><LF>
     * Emits `ondone`.
     *
     * @param {Object} command Parsed command from the server {statusCode, data, line}
     */

  }, {
    key: '_actionStream',
    value: function _actionStream(command) {
      var rcpt;

      if (this.options.lmtp) {
        // LMTP returns a response code for *every* successfully set recipient
        // For every recipient the message might succeed or fail individually

        rcpt = this._envelope.responseQueue.shift();
        if (!command.success) {
          this.logger.error(DEBUG_TAG, 'Local delivery to ' + rcpt + ' failed.');
          this._envelope.rcptFailed.push(rcpt);
        } else {
          this.logger.error(DEBUG_TAG, 'Local delivery to ' + rcpt + ' succeeded.');
        }

        if (this._envelope.responseQueue.length) {
          this._currentAction = this._actionStream;
          return;
        }

        this._currentAction = this._actionIdle;
        this.ondone(true);
      } else {
        // For SMTP the message either fails or succeeds, there is no information
        // about individual recipients

        if (!command.success) {
          this.logger.error(DEBUG_TAG, 'Message sending failed.');
        } else {
          this.logger.debug(DEBUG_TAG, 'Message sent successfully.');
        }

        this._currentAction = this._actionIdle;
        this.ondone(!!command.success);
      }

      // If the client wanted to do something else (eg. to quit), do not force idle
      if (this._currentAction === this._actionIdle) {
        // Waiting for new connections
        this.logger.debug(DEBUG_TAG, 'Idling while waiting for new connections...');
        this.onidle();
      }
    }

    /**
     * Builds a login token for XOAUTH2 authentication command
     *
     * @param {String} user E-mail address of the user
     * @param {String} token Valid access token for the user
     * @return {String} Base64 formatted login token
     */

  }, {
    key: '_buildXOAuth2Token',
    value: function _buildXOAuth2Token(user, token) {
      var authData = ['user=' + (user || ''), 'auth=Bearer ' + token, '', ''];
      // base64("user={User}\x00auth=Bearer {Token}\x00\x00")
      return (0, _emailjsBase.encode)(authData.join('\x01'));
    }
  }, {
    key: 'createLogger',
    value: function createLogger() {
      var _this = this;

      var creator = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _logger2.default;

      var logger = creator((this.options.auth || {}).user || '', this.host);
      this.logLevel = this.LOG_LEVEL_ALL;
      this.logger = {
        debug: function debug() {
          for (var _len = arguments.length, msgs = Array(_len), _key = 0; _key < _len; _key++) {
            msgs[_key] = arguments[_key];
          }

          if (_common.LOG_LEVEL_DEBUG >= _this.logLevel) {
            logger.debug(msgs);
          }
        },
        info: function info() {
          for (var _len2 = arguments.length, msgs = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
            msgs[_key2] = arguments[_key2];
          }

          if (_common.LOG_LEVEL_INFO >= _this.logLevel) {
            logger.info(msgs);
          }
        },
        warn: function warn() {
          for (var _len3 = arguments.length, msgs = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
            msgs[_key3] = arguments[_key3];
          }

          if (_common.LOG_LEVEL_WARN >= _this.logLevel) {
            logger.warn(msgs);
          }
        },
        error: function error() {
          for (var _len4 = arguments.length, msgs = Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
            msgs[_key4] = arguments[_key4];
          }

          if (_common.LOG_LEVEL_ERROR >= _this.logLevel) {
            logger.error(msgs);
          }
        }
      };
    }
  }]);

  return SmtpClient;
}();

exports.default = SmtpClient;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/client.js"],"names":["DEBUG_TAG","TIMEOUT_SOCKET_LOWER_BOUND","TIMEOUT_SOCKET_MULTIPLIER","SmtpClient","host","port","options","timeoutSocketLowerBound","timeoutSocketMultiplier","useSecureTransport","auth","name","socket","destroyed","waitDrain","_parser","SmtpClientResponseParser","_authenticatedAs","_supportedAuth","_dataMode","_lastDataBytes","_envelope","_currentAction","_secureMode","_socketTimeoutTimer","_socketTimeoutStart","_socketTimeoutPeriod","createLogger","onerror","e","ondrain","onclose","onidle","onready","failedRecipients","ondone","success","SocketContructor","TCPSocket","open","binaryType","ca","tlsWorkerPath","ws","oncert","E","_onError","bind","onopen","_onOpen","readyState","suspend","resume","logger","debug","_sendCommand","close","_actionRSET","_destroy","envelope","from","concat","to","rcptQueue","rcptFailed","responseQueue","_actionMAIL","chunk","_sendString","length","send","_actionStream","_send","Uint8Array","buffer","substr","event","data","proxyHostname","ondata","_onData","_onClose","_onDrain","_onCommand","_actionGreeting","evt","clearTimeout","stringPayload","TextDecoder","decode","Error","message","error","command","disableEscaping","replace","charAt","TextEncoder","encode","str","_setTimeout","byteLength","prolongPeriod","Math","floor","timeout","now","Date","setTimeout","_onTimeout","_actionIdle","authMethod","xoauth2","toUpperCase","trim","_actionAUTH_LOGIN_USER","_actionAUTHComplete","user","pass","_actionAUTH_XOAUTH2","_buildXOAuth2Token","statusCode","lmtp","_actionLHLO","_actionEHLO","match","requireTLS","errMsg","warn","_actionHELO","line","push","Number","maxAllowedSize","ignoreTLS","_actionSTARTTLS","_authenticateUser","upgradeToSecure","_actionAUTH_LOGIN_PASS","curRecipient","shift","_actionRCPT","_actionDATA","indexOf","rcpt","token","authData","join","creator","createDefaultLogger","logLevel","LOG_LEVEL_ALL","msgs","LOG_LEVEL_DEBUG","info","LOG_LEVEL_INFO","LOG_LEVEL_WARN","LOG_LEVEL_ERROR"],"mappings":"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","file":"client.js","sourcesContent":["/* eslint-disable camelcase */\n\nimport { encode } from 'emailjs-base64'\nimport TCPSocket from 'emailjs-tcp-socket'\nimport { TextDecoder, TextEncoder } from 'text-encoding'\nimport SmtpClientResponseParser from './parser'\nimport createDefaultLogger from './logger'\nimport {\n  LOG_LEVEL_ERROR,\n  LOG_LEVEL_WARN,\n  LOG_LEVEL_INFO,\n  LOG_LEVEL_DEBUG\n} from './common'\n\nvar DEBUG_TAG = 'SMTP Client'\n\n/**\n * Lower Bound for socket timeout to wait since the last data was written to a socket\n */\nconst TIMEOUT_SOCKET_LOWER_BOUND = 10000\n\n/**\n * Multiplier for socket timeout:\n *\n * We assume at least a GPRS connection with 115 kb/s = 14,375 kB/s tops, so 10 KB/s to be on\n * the safe side. We can timeout after a lower bound of 10s + (n KB / 10 KB/s). A 1 MB message\n * upload would be 110 seconds to wait for the timeout. 10 KB/s === 0.1 s/B\n */\nconst TIMEOUT_SOCKET_MULTIPLIER = 0.1\n\nclass SmtpClient {\n  /**\n   * Creates a connection object to a SMTP server and allows to send mail through it.\n   * Call `connect` method to inititate the actual connection, the constructor only\n   * defines the properties but does not actually connect.\n   *\n   * NB! The parameter order (host, port) differs from node.js \"way\" (port, host)\n   *\n   * @constructor\n   *\n   * @param {String} [host=\"localhost\"] Hostname to conenct to\n   * @param {Number} [port=25] Port number to connect to\n   * @param {Object} [options] Optional options object\n   * @param {Boolean} [options.useSecureTransport] Set to true, to use encrypted connection\n   * @param {String} [options.name] Client hostname for introducing itself to the server\n   * @param {Object} [options.auth] Authentication options. Depends on the preferred authentication method. Usually {user, pass}\n   * @param {String} [options.authMethod] Force specific authentication method\n   * @param {Boolean} [options.disableEscaping] If set to true, do not escape dots on the beginning of the lines\n   */\n  constructor (host, port, options = {}) {\n    this.options = options\n\n    this.timeoutSocketLowerBound = TIMEOUT_SOCKET_LOWER_BOUND\n    this.timeoutSocketMultiplier = TIMEOUT_SOCKET_MULTIPLIER\n\n    this.port = port || (this.options.useSecureTransport ? 465 : 25)\n    this.host = host || 'localhost'\n\n    /**\n     * If set to true, start an encrypted connection instead of the plaintext one\n     * (recommended if applicable). If useSecureTransport is not set but the port used is 465,\n     * then ecryption is used by default.\n     */\n    this.options.useSecureTransport = 'useSecureTransport' in this.options ? !!this.options.useSecureTransport : this.port === 465\n\n    this.options.auth = this.options.auth || false // Authentication object. If not set, authentication step will be skipped.\n    this.options.name = this.options.name || 'localhost' // Hostname of the client, this will be used for introducing to the server\n    this.socket = false // Downstream TCP socket to the SMTP server, created with mozTCPSocket\n    this.destroyed = false // Indicates if the connection has been closed and can't be used anymore\n    this.waitDrain = false // Keeps track if the downstream socket is currently full and a drain event should be waited for or not\n\n    // Private properties\n\n    this._parser = new SmtpClientResponseParser() // SMTP response parser object. All data coming from the downstream server is feeded to this parser\n    this._authenticatedAs = null // If authenticated successfully, stores the username\n    this._supportedAuth = [] // A list of authentication mechanisms detected from the EHLO response and which are compatible with this library\n    this._dataMode = false // If true, accepts data from the upstream to be passed directly to the downstream socket. Used after the DATA command\n    this._lastDataBytes = '' // Keep track of the last bytes to see how the terminating dot should be placed\n    this._envelope = null // Envelope object for tracking who is sending mail to whom\n    this._currentAction = null // Stores the function that should be run after a response has been received from the server\n    this._secureMode = !!this.options.useSecureTransport // Indicates if the connection is secured or plaintext\n    this._socketTimeoutTimer = false // Timer waiting to declare the socket dead starting from the last write\n    this._socketTimeoutStart = false // Start time of sending the first packet in data mode\n    this._socketTimeoutPeriod = false // Timeout for sending in data mode, gets extended with every send()\n\n    // Activate logging\n    this.createLogger()\n\n    // Event placeholders\n    this.onerror = (e) => { } // Will be run when an error occurs. The `onclose` event will fire subsequently.\n    this.ondrain = () => { } // More data can be buffered in the socket.\n    this.onclose = () => { } // The connection to the server has been closed\n    this.onidle = () => { } // The connection is established and idle, you can send mail now\n    this.onready = (failedRecipients) => { } // Waiting for mail body, lists addresses that were not accepted as recipients\n    this.ondone = (success) => { } // The mail has been sent. Wait for `onidle` next. Indicates if the message was queued by the server.\n  }\n\n  /**\n   * Initiate a connection to the server\n   */\n  connect (SocketContructor = TCPSocket) {\n    this.socket = SocketContructor.open(this.host, this.port, {\n      binaryType: 'arraybuffer',\n      useSecureTransport: this._secureMode,\n      ca: this.options.ca,\n      tlsWorkerPath: this.options.tlsWorkerPath,\n      ws: this.options.ws\n    })\n\n    // allows certificate handling for platform w/o native tls support\n    // oncert is non standard so setting it might throw if the socket object is immutable\n    try {\n      this.socket.oncert = this.oncert\n    } catch (E) { }\n    this.socket.onerror = this._onError.bind(this)\n    this.socket.onopen = this._onOpen.bind(this)\n  }\n\n  /**\n   * Pauses `data` events from the downstream SMTP server\n   */\n  suspend () {\n    if (this.socket && this.socket.readyState === 'open') {\n      this.socket.suspend()\n    }\n  }\n\n  /**\n   * Resumes `data` events from the downstream SMTP server. Be careful of not\n   * resuming something that is not suspended - an error is thrown in this case\n   */\n  resume () {\n    if (this.socket && this.socket.readyState === 'open') {\n      this.socket.resume()\n    }\n  }\n\n  /**\n   * Sends QUIT\n   */\n  quit () {\n    this.logger.debug(DEBUG_TAG, 'Sending QUIT...')\n    this._sendCommand('QUIT')\n    this._currentAction = this.close\n  }\n\n  /**\n   * Reset authentication\n   *\n   * @param {Object} [auth] Use this if you want to authenticate as another user\n   */\n  reset (auth) {\n    this.options.auth = auth || this.options.auth\n    this.logger.debug(DEBUG_TAG, 'Sending RSET...')\n    this._sendCommand('RSET')\n    this._currentAction = this._actionRSET\n  }\n\n  /**\n   * Closes the connection to the server\n   */\n  close () {\n    this.logger.debug(DEBUG_TAG, 'Closing connection...')\n    if (this.socket && this.socket.readyState === 'open') {\n      this.socket.close()\n    } else {\n      this._destroy()\n    }\n  }\n\n  // Mail related methods\n\n  /**\n   * Initiates a new message by submitting envelope data, starting with\n   * `MAIL FROM:` command. Use after `onidle` event\n   *\n   * @param {Object} envelope Envelope object in the form of {from:\"...\", to:[\"...\"]}\n   */\n  useEnvelope (envelope) {\n    this._envelope = envelope || {}\n    this._envelope.from = [].concat(this._envelope.from || ('anonymous@' + this.options.name))[0]\n    this._envelope.to = [].concat(this._envelope.to || [])\n\n    // clone the recipients array for latter manipulation\n    this._envelope.rcptQueue = [].concat(this._envelope.to)\n    this._envelope.rcptFailed = []\n    this._envelope.responseQueue = []\n\n    this._currentAction = this._actionMAIL\n    this.logger.debug(DEBUG_TAG, 'Sending MAIL FROM...')\n    this._sendCommand('MAIL FROM:<' + (this._envelope.from) + '>')\n  }\n\n  /**\n   * Send ASCII data to the server. Works only in data mode (after `onready` event), ignored\n   * otherwise\n   *\n   * @param {String} chunk ASCII string (quoted-printable, base64 etc.) to be sent to the server\n   * @return {Boolean} If true, it is safe to send more data, if false, you *should* wait for the ondrain event before sending more\n   */\n  send (chunk) {\n    // works only in data mode\n    if (!this._dataMode) {\n      // this line should never be reached but if it does,\n      // act like everything's normal.\n      return true\n    }\n\n    // TODO: if the chunk is an arraybuffer, use a separate function to send the data\n    return this._sendString(chunk)\n  }\n\n  /**\n   * Indicates that a data stream for the socket is ended. Works only in data\n   * mode (after `onready` event), ignored otherwise. Use it when you are done\n   * with sending the mail. This method does not close the socket. Once the mail\n   * has been queued by the server, `ondone` and `onidle` are emitted.\n   *\n   * @param {Buffer} [chunk] Chunk of data to be sent to the server\n   */\n  end (chunk) {\n    // works only in data mode\n    if (!this._dataMode) {\n      // this line should never be reached but if it does,\n      // act like everything's normal.\n      return true\n    }\n\n    if (chunk && chunk.length) {\n      this.send(chunk)\n    }\n\n    // redirect output from the server to _actionStream\n    this._currentAction = this._actionStream\n\n    // indicate that the stream has ended by sending a single dot on its own line\n    // if the client already closed the data with \\r\\n no need to do it again\n    if (this._lastDataBytes === '\\r\\n') {\n      this.waitDrain = this._send(new Uint8Array([0x2E, 0x0D, 0x0A]).buffer) // .\\r\\n\n    } else if (this._lastDataBytes.substr(-1) === '\\r') {\n      this.waitDrain = this._send(new Uint8Array([0x0A, 0x2E, 0x0D, 0x0A]).buffer) // \\n.\\r\\n\n    } else {\n      this.waitDrain = this._send(new Uint8Array([0x0D, 0x0A, 0x2E, 0x0D, 0x0A]).buffer) // \\r\\n.\\r\\n\n    }\n\n    // end data mode, reset the variables for extending the timeout in data mode\n    this._dataMode = false\n    this._socketTimeoutStart = false\n    this._socketTimeoutPeriod = false\n\n    return this.waitDrain\n  }\n\n  // PRIVATE METHODS\n\n  // EVENT HANDLERS FOR THE SOCKET\n\n  /**\n   * Connection listener that is run when the connection to the server is opened.\n   * Sets up different event handlers for the opened socket\n   *\n   * @event\n   * @param {Event} evt Event object. Not used\n   */\n  _onOpen (event) {\n    if (event && event.data && event.data.proxyHostname) {\n      this.options.name = event.data.proxyHostname\n    }\n\n    this.socket.ondata = this._onData.bind(this)\n\n    this.socket.onclose = this._onClose.bind(this)\n    this.socket.ondrain = this._onDrain.bind(this)\n\n    this._parser.ondata = this._onCommand.bind(this)\n\n    this._currentAction = this._actionGreeting\n  }\n\n  /**\n   * Data listener for chunks of data emitted by the server\n   *\n   * @event\n   * @param {Event} evt Event object. See `evt.data` for the chunk received\n   */\n  _onData (evt) {\n    clearTimeout(this._socketTimeoutTimer)\n    var stringPayload = new TextDecoder('UTF-8').decode(new Uint8Array(evt.data))\n    this.logger.debug(DEBUG_TAG, 'SERVER: ' + stringPayload)\n    this._parser.send(stringPayload)\n  }\n\n  /**\n   * More data can be buffered in the socket, `waitDrain` is reset to false\n   *\n   * @event\n   * @param {Event} evt Event object. Not used\n   */\n  _onDrain () {\n    this.waitDrain = false\n    this.ondrain()\n  }\n\n  /**\n   * Error handler for the socket\n   *\n   * @event\n   * @param {Event} evt Event object. See evt.data for the error\n   */\n  _onError (evt) {\n    if (evt instanceof Error && evt.message) {\n      this.logger.error(DEBUG_TAG, evt)\n      this.onerror(evt)\n    } else if (evt && evt.data instanceof Error) {\n      this.logger.error(DEBUG_TAG, evt.data)\n      this.onerror(evt.data)\n    } else {\n      this.logger.error(DEBUG_TAG, new Error((evt && evt.data && evt.data.message) || evt.data || evt || 'Error'))\n      this.onerror(new Error((evt && evt.data && evt.data.message) || evt.data || evt || 'Error'))\n    }\n\n    this.close()\n  }\n\n  /**\n   * Indicates that the socket has been closed\n   *\n   * @event\n   * @param {Event} evt Event object. Not used\n   */\n  _onClose () {\n    this.logger.debug(DEBUG_TAG, 'Socket closed.')\n    this._destroy()\n  }\n\n  /**\n   * This is not a socket data handler but the handler for data emitted by the parser,\n   * so this data is safe to use as it is always complete (server might send partial chunks)\n   *\n   * @event\n   * @param {Object} command Parsed data\n   */\n  _onCommand (command) {\n    if (typeof this._currentAction === 'function') {\n      this._currentAction(command)\n    }\n  }\n\n  _onTimeout () {\n    // inform about the timeout and shut down\n    var error = new Error('Socket timed out!')\n    this._onError(error)\n  }\n\n  /**\n   * Ensures that the connection is closed and such\n   */\n  _destroy () {\n    clearTimeout(this._socketTimeoutTimer)\n\n    if (!this.destroyed) {\n      this.destroyed = true\n      this.onclose()\n    }\n  }\n\n  /**\n   * Sends a string to the socket.\n   *\n   * @param {String} chunk ASCII string (quoted-printable, base64 etc.) to be sent to the server\n   * @return {Boolean} If true, it is safe to send more data, if false, you *should* wait for the ondrain event before sending more\n   */\n  _sendString (chunk) {\n    // escape dots\n    if (!this.options.disableEscaping) {\n      chunk = chunk.replace(/\\n\\./g, '\\n..')\n      if ((this._lastDataBytes.substr(-1) === '\\n' || !this._lastDataBytes) && chunk.charAt(0) === '.') {\n        chunk = '.' + chunk\n      }\n    }\n\n    // Keeping eye on the last bytes sent, to see if there is a <CR><LF> sequence\n    // at the end which is needed to end the data stream\n    if (chunk.length > 2) {\n      this._lastDataBytes = chunk.substr(-2)\n    } else if (chunk.length === 1) {\n      this._lastDataBytes = this._lastDataBytes.substr(-1) + chunk\n    }\n\n    this.logger.debug(DEBUG_TAG, 'Sending ' + chunk.length + ' bytes of payload')\n\n    // pass the chunk to the socket\n    this.waitDrain = this._send(new TextEncoder('UTF-8').encode(chunk).buffer)\n    return this.waitDrain\n  }\n\n  /**\n   * Send a string command to the server, also append \\r\\n if needed\n   *\n   * @param {String} str String to be sent to the server\n   */\n  _sendCommand (str) {\n    this.waitDrain = this._send(new TextEncoder('UTF-8').encode(str + (str.substr(-2) !== '\\r\\n' ? '\\r\\n' : '')).buffer)\n  }\n\n  _send (buffer) {\n    this._setTimeout(buffer.byteLength)\n    return this.socket.send(buffer)\n  }\n\n  _setTimeout (byteLength) {\n    var prolongPeriod = Math.floor(byteLength * this.timeoutSocketMultiplier)\n    var timeout\n\n    if (this._dataMode) {\n      // we're in data mode, so we count only one timeout that get extended for every send().\n      var now = Date.now()\n\n      // the old timeout start time\n      this._socketTimeoutStart = this._socketTimeoutStart || now\n\n      // the old timeout period, normalized to a minimum of TIMEOUT_SOCKET_LOWER_BOUND\n      this._socketTimeoutPeriod = (this._socketTimeoutPeriod || this.timeoutSocketLowerBound) + prolongPeriod\n\n      // the new timeout is the delta between the new firing time (= timeout period + timeout start time) and now\n      timeout = this._socketTimeoutStart + this._socketTimeoutPeriod - now\n    } else {\n      // set new timout\n      timeout = this.timeoutSocketLowerBound + prolongPeriod\n    }\n\n    clearTimeout(this._socketTimeoutTimer) // clear pending timeouts\n    this._socketTimeoutTimer = setTimeout(this._onTimeout.bind(this), timeout) // arm the next timeout\n  }\n\n  /**\n   * Intitiate authentication sequence if needed\n   */\n  _authenticateUser () {\n    if (!this.options.auth) {\n      // no need to authenticate, at least no data given\n      this._currentAction = this._actionIdle\n      this.onidle() // ready to take orders\n      return\n    }\n\n    var auth\n\n    if (!this.options.authMethod && this.options.auth.xoauth2) {\n      this.options.authMethod = 'XOAUTH2'\n    }\n\n    if (this.options.authMethod) {\n      auth = this.options.authMethod.toUpperCase().trim()\n    } else {\n      // use first supported\n      auth = (this._supportedAuth[0] || 'PLAIN').toUpperCase().trim()\n    }\n\n    switch (auth) {\n      case 'LOGIN':\n        // LOGIN is a 3 step authentication process\n        // C: AUTH LOGIN\n        // C: BASE64(USER)\n        // C: BASE64(PASS)\n        this.logger.debug(DEBUG_TAG, 'Authentication via AUTH LOGIN')\n        this._currentAction = this._actionAUTH_LOGIN_USER\n        this._sendCommand('AUTH LOGIN')\n        return\n      case 'PLAIN':\n        // AUTH PLAIN is a 1 step authentication process\n        // C: AUTH PLAIN BASE64(\\0 USER \\0 PASS)\n        this.logger.debug(DEBUG_TAG, 'Authentication via AUTH PLAIN')\n        this._currentAction = this._actionAUTHComplete\n        this._sendCommand(\n          // convert to BASE64\n          'AUTH PLAIN ' +\n          encode(\n            // this.options.auth.user+'\\u0000'+\n            '\\u0000' + // skip authorization identity as it causes problems with some servers\n            this.options.auth.user + '\\u0000' +\n            this.options.auth.pass)\n        )\n        return\n      case 'XOAUTH2':\n        // See https://developers.google.com/gmail/xoauth2_protocol#smtp_protocol_exchange\n        this.logger.debug(DEBUG_TAG, 'Authentication via AUTH XOAUTH2')\n        this._currentAction = this._actionAUTH_XOAUTH2\n        this._sendCommand('AUTH XOAUTH2 ' + this._buildXOAuth2Token(this.options.auth.user, this.options.auth.xoauth2))\n        return\n    }\n\n    this._onError(new Error('Unknown authentication method ' + auth))\n  }\n\n  // ACTIONS FOR RESPONSES FROM THE SMTP SERVER\n\n  /**\n   * Initial response from the server, must have a status 220\n   *\n   * @param {Object} command Parsed command from the server {statusCode, data, line}\n   */\n  _actionGreeting (command) {\n    if (command.statusCode !== 220) {\n      this._onError(new Error('Invalid greeting: ' + command.data))\n      return\n    }\n\n    if (this.options.lmtp) {\n      this.logger.debug(DEBUG_TAG, 'Sending LHLO ' + this.options.name)\n\n      this._currentAction = this._actionLHLO\n      this._sendCommand('LHLO ' + this.options.name)\n    } else {\n      this.logger.debug(DEBUG_TAG, 'Sending EHLO ' + this.options.name)\n\n      this._currentAction = this._actionEHLO\n      this._sendCommand('EHLO ' + this.options.name)\n    }\n  }\n\n  /**\n   * Response to LHLO\n   *\n   * @param {Object} command Parsed command from the server {statusCode, data, line}\n   */\n  _actionLHLO (command) {\n    if (!command.success) {\n      this.logger.error(DEBUG_TAG, 'LHLO not successful')\n      this._onError(new Error(command.data))\n      return\n    }\n\n    // Process as EHLO response\n    this._actionEHLO(command)\n  }\n\n  /**\n   * Response to EHLO. If the response is an error, try HELO instead\n   *\n   * @param {Object} command Parsed command from the server {statusCode, data, line}\n   */\n  _actionEHLO (command) {\n    var match\n\n    if (!command.success) {\n      if (!this._secureMode && this.options.requireTLS) {\n        var errMsg = 'STARTTLS not supported without EHLO'\n        this.logger.error(DEBUG_TAG, errMsg)\n        this._onError(new Error(errMsg))\n        return\n      }\n\n      // Try HELO instead\n      this.logger.warn(DEBUG_TAG, 'EHLO not successful, trying HELO ' + this.options.name)\n      this._currentAction = this._actionHELO\n      this._sendCommand('HELO ' + this.options.name)\n      return\n    }\n\n    // Detect if the server supports PLAIN auth\n    if (command.line.match(/AUTH(?:\\s+[^\\n]*\\s+|\\s+)PLAIN/i)) {\n      this.logger.debug(DEBUG_TAG, 'Server supports AUTH PLAIN')\n      this._supportedAuth.push('PLAIN')\n    }\n\n    // Detect if the server supports LOGIN auth\n    if (command.line.match(/AUTH(?:\\s+[^\\n]*\\s+|\\s+)LOGIN/i)) {\n      this.logger.debug(DEBUG_TAG, 'Server supports AUTH LOGIN')\n      this._supportedAuth.push('LOGIN')\n    }\n\n    // Detect if the server supports XOAUTH2 auth\n    if (command.line.match(/AUTH(?:\\s+[^\\n]*\\s+|\\s+)XOAUTH2/i)) {\n      this.logger.debug(DEBUG_TAG, 'Server supports AUTH XOAUTH2')\n      this._supportedAuth.push('XOAUTH2')\n    }\n\n    // Detect maximum allowed message size\n    if ((match = command.line.match(/SIZE (\\d+)/i)) && Number(match[1])) {\n      const maxAllowedSize = Number(match[1])\n      this.logger.debug(DEBUG_TAG, 'Maximum allowd message size: ' + maxAllowedSize)\n    }\n\n    // Detect if the server supports STARTTLS\n    if (!this._secureMode) {\n      if ((command.line.match(/[ -]STARTTLS\\s?$/mi) && !this.options.ignoreTLS) || !!this.options.requireTLS) {\n        this._currentAction = this._actionSTARTTLS\n        this.logger.debug(DEBUG_TAG, 'Sending STARTTLS')\n        this._sendCommand('STARTTLS')\n        return\n      }\n    }\n\n    this._authenticateUser()\n  }\n\n  /**\n   * Handles server response for STARTTLS command. If there's an error\n   * try HELO instead, otherwise initiate TLS upgrade. If the upgrade\n   * succeedes restart the EHLO\n   *\n   * @param {String} str Message from the server\n   */\n  _actionSTARTTLS (command) {\n    if (!command.success) {\n      this.logger.error(DEBUG_TAG, 'STARTTLS not successful')\n      this._onError(new Error(command.data))\n      return\n    }\n\n    this._secureMode = true\n    this.socket.upgradeToSecure()\n\n    // restart protocol flow\n    this._currentAction = this._actionEHLO\n    this._sendCommand('EHLO ' + this.options.name)\n  }\n\n  /**\n   * Response to HELO\n   *\n   * @param {Object} command Parsed command from the server {statusCode, data, line}\n   */\n  _actionHELO (command) {\n    if (!command.success) {\n      this.logger.error(DEBUG_TAG, 'HELO not successful')\n      this._onError(new Error(command.data))\n      return\n    }\n    this._authenticateUser()\n  }\n\n  /**\n   * Response to AUTH LOGIN, if successful expects base64 encoded username\n   *\n   * @param {Object} command Parsed command from the server {statusCode, data, line}\n   */\n  _actionAUTH_LOGIN_USER (command) {\n    if (command.statusCode !== 334 || command.data !== 'VXNlcm5hbWU6') {\n      this.logger.error(DEBUG_TAG, 'AUTH LOGIN USER not successful: ' + command.data)\n      this._onError(new Error('Invalid login sequence while waiting for \"334 VXNlcm5hbWU6 \": ' + command.data))\n      return\n    }\n    this.logger.debug(DEBUG_TAG, 'AUTH LOGIN USER successful')\n    this._currentAction = this._actionAUTH_LOGIN_PASS\n    this._sendCommand(encode(this.options.auth.user))\n  }\n\n  /**\n   * Response to AUTH LOGIN username, if successful expects base64 encoded password\n   *\n   * @param {Object} command Parsed command from the server {statusCode, data, line}\n   */\n  _actionAUTH_LOGIN_PASS (command) {\n    if (command.statusCode !== 334 || command.data !== 'UGFzc3dvcmQ6') {\n      this.logger.error(DEBUG_TAG, 'AUTH LOGIN PASS not successful: ' + command.data)\n      this._onError(new Error('Invalid login sequence while waiting for \"334 UGFzc3dvcmQ6 \": ' + command.data))\n      return\n    }\n    this.logger.debug(DEBUG_TAG, 'AUTH LOGIN PASS successful')\n    this._currentAction = this._actionAUTHComplete\n    this._sendCommand(encode(this.options.auth.pass))\n  }\n\n  /**\n   * Response to AUTH XOAUTH2 token, if error occurs send empty response\n   *\n   * @param {Object} command Parsed command from the server {statusCode, data, line}\n   */\n  _actionAUTH_XOAUTH2 (command) {\n    if (!command.success) {\n      this.logger.warn(DEBUG_TAG, 'Error during AUTH XOAUTH2, sending empty response')\n      this._sendCommand('')\n      this._currentAction = this._actionAUTHComplete\n    } else {\n      this._actionAUTHComplete(command)\n    }\n  }\n\n  /**\n   * Checks if authentication succeeded or not. If successfully authenticated\n   * emit `idle` to indicate that an e-mail can be sent using this connection\n   *\n   * @param {Object} command Parsed command from the server {statusCode, data, line}\n   */\n  _actionAUTHComplete (command) {\n    if (!command.success) {\n      this.logger.debug(DEBUG_TAG, 'Authentication failed: ' + command.data)\n      this._onError(new Error(command.data))\n      return\n    }\n\n    this.logger.debug(DEBUG_TAG, 'Authentication successful.')\n\n    this._authenticatedAs = this.options.auth.user\n\n    this._currentAction = this._actionIdle\n    this.onidle() // ready to take orders\n  }\n\n  /**\n   * Used when the connection is idle and the server emits timeout\n   *\n   * @param {Object} command Parsed command from the server {statusCode, data, line}\n   */\n  _actionIdle (command) {\n    if (command.statusCode > 300) {\n      this._onError(new Error(command.line))\n      return\n    }\n\n    this._onError(new Error(command.data))\n  }\n\n  /**\n   * Response to MAIL FROM command. Proceed to defining RCPT TO list if successful\n   *\n   * @param {Object} command Parsed command from the server {statusCode, data, line}\n   */\n  _actionMAIL (command) {\n    if (!command.success) {\n      this.logger.debug(DEBUG_TAG, 'MAIL FROM unsuccessful: ' + command.data)\n      this._onError(new Error(command.data))\n      return\n    }\n\n    if (!this._envelope.rcptQueue.length) {\n      this._onError(new Error('Can\\'t send mail - no recipients defined'))\n    } else {\n      this.logger.debug(DEBUG_TAG, 'MAIL FROM successful, proceeding with ' + this._envelope.rcptQueue.length + ' recipients')\n      this.logger.debug(DEBUG_TAG, 'Adding recipient...')\n      this._envelope.curRecipient = this._envelope.rcptQueue.shift()\n      this._currentAction = this._actionRCPT\n      this._sendCommand('RCPT TO:<' + this._envelope.curRecipient + '>')\n    }\n  }\n\n  /**\n   * Response to a RCPT TO command. If the command is unsuccessful, try the next one,\n   * as this might be related only to the current recipient, not a global error, so\n   * the following recipients might still be valid\n   *\n   * @param {Object} command Parsed command from the server {statusCode, data, line}\n   */\n  _actionRCPT (command) {\n    if (!command.success) {\n      this.logger.warn(DEBUG_TAG, 'RCPT TO failed for: ' + this._envelope.curRecipient)\n      // this is a soft error\n      this._envelope.rcptFailed.push(this._envelope.curRecipient)\n    } else {\n      this._envelope.responseQueue.push(this._envelope.curRecipient)\n    }\n\n    if (!this._envelope.rcptQueue.length) {\n      if (this._envelope.rcptFailed.length < this._envelope.to.length) {\n        this._currentAction = this._actionDATA\n        this.logger.debug(DEBUG_TAG, 'RCPT TO done, proceeding with payload')\n        this._sendCommand('DATA')\n      } else {\n        this._onError(new Error('Can\\'t send mail - all recipients were rejected'))\n        this._currentAction = this._actionIdle\n      }\n    } else {\n      this.logger.debug(DEBUG_TAG, 'Adding recipient...')\n      this._envelope.curRecipient = this._envelope.rcptQueue.shift()\n      this._currentAction = this._actionRCPT\n      this._sendCommand('RCPT TO:<' + this._envelope.curRecipient + '>')\n    }\n  }\n\n  /**\n   * Response to the RSET command. If successful, clear the current authentication\n   * information and reauthenticate.\n   *\n   * @param {Object} command Parsed command from the server {statusCode, data, line}\n   */\n  _actionRSET (command) {\n    if (!command.success) {\n      this.logger.error(DEBUG_TAG, 'RSET unsuccessful ' + command.data)\n      this._onError(new Error(command.data))\n      return\n    }\n\n    this._authenticatedAs = null\n    this._authenticateUser()\n  }\n\n  /**\n   * Response to the DATA command. Server is now waiting for a message, so emit `onready`\n   *\n   * @param {Object} command Parsed command from the server {statusCode, data, line}\n   */\n  _actionDATA (command) {\n    // response should be 354 but according to this issue https://github.com/eleith/emailjs/issues/24\n    // some servers might use 250 instead\n    if ([250, 354].indexOf(command.statusCode) < 0) {\n      this.logger.error(DEBUG_TAG, 'DATA unsuccessful ' + command.data)\n      this._onError(new Error(command.data))\n      return\n    }\n\n    this._dataMode = true\n    this._currentAction = this._actionIdle\n    this.onready(this._envelope.rcptFailed)\n  }\n\n  /**\n   * Response from the server, once the message stream has ended with <CR><LF>.<CR><LF>\n   * Emits `ondone`.\n   *\n   * @param {Object} command Parsed command from the server {statusCode, data, line}\n   */\n  _actionStream (command) {\n    var rcpt\n\n    if (this.options.lmtp) {\n      // LMTP returns a response code for *every* successfully set recipient\n      // For every recipient the message might succeed or fail individually\n\n      rcpt = this._envelope.responseQueue.shift()\n      if (!command.success) {\n        this.logger.error(DEBUG_TAG, 'Local delivery to ' + rcpt + ' failed.')\n        this._envelope.rcptFailed.push(rcpt)\n      } else {\n        this.logger.error(DEBUG_TAG, 'Local delivery to ' + rcpt + ' succeeded.')\n      }\n\n      if (this._envelope.responseQueue.length) {\n        this._currentAction = this._actionStream\n        return\n      }\n\n      this._currentAction = this._actionIdle\n      this.ondone(true)\n    } else {\n      // For SMTP the message either fails or succeeds, there is no information\n      // about individual recipients\n\n      if (!command.success) {\n        this.logger.error(DEBUG_TAG, 'Message sending failed.')\n      } else {\n        this.logger.debug(DEBUG_TAG, 'Message sent successfully.')\n      }\n\n      this._currentAction = this._actionIdle\n      this.ondone(!!command.success)\n    }\n\n    // If the client wanted to do something else (eg. to quit), do not force idle\n    if (this._currentAction === this._actionIdle) {\n      // Waiting for new connections\n      this.logger.debug(DEBUG_TAG, 'Idling while waiting for new connections...')\n      this.onidle()\n    }\n  }\n\n  /**\n   * Builds a login token for XOAUTH2 authentication command\n   *\n   * @param {String} user E-mail address of the user\n   * @param {String} token Valid access token for the user\n   * @return {String} Base64 formatted login token\n   */\n  _buildXOAuth2Token (user, token) {\n    var authData = [\n      'user=' + (user || ''),\n      'auth=Bearer ' + token,\n      '',\n      ''\n    ]\n    // base64(\"user={User}\\x00auth=Bearer {Token}\\x00\\x00\")\n    return encode(authData.join('\\x01'))\n  }\n\n  createLogger (creator = createDefaultLogger) {\n    const logger = creator((this.options.auth || {}).user || '', this.host)\n    this.logLevel = this.LOG_LEVEL_ALL\n    this.logger = {\n      debug: (...msgs) => { if (LOG_LEVEL_DEBUG >= this.logLevel) { logger.debug(msgs) } },\n      info: (...msgs) => { if (LOG_LEVEL_INFO >= this.logLevel) { logger.info(msgs) } },\n      warn: (...msgs) => { if (LOG_LEVEL_WARN >= this.logLevel) { logger.warn(msgs) } },\n      error: (...msgs) => { if (LOG_LEVEL_ERROR >= this.logLevel) { logger.error(msgs) } }\n    }\n  }\n}\n\nexport default SmtpClient\n"]}