react-strophe/src/websocket.js

Strophe.js is an XMPP library for JavaScript

/*
    This program is distributed under the terms of the MIT license.
    Please see the LICENSE file for details.

    Copyright 2006-2008, OGG, LLC
*/

/** Class: Strophe.WebSocket
 *  _Private_ helper class that handles WebSocket Connections
 *
 *  The Strophe.WebSocket class is used internally by Strophe.Connection
 *  to encapsulate WebSocket sessions. It is not meant to be used from user's code.
 */

/** File: websocket.js
 *  A JavaScript library to enable XMPP over Websocket in Strophejs.
 *
 *  This file implements XMPP over WebSockets for Strophejs.
 *  If a Connection is established with a Websocket url (ws://...)
 *  Strophe will use WebSockets.
 *  For more information on XMPP-over-WebSocket see RFC 7395:
 *  http://tools.ietf.org/html/rfc7395
 *
 *  WebSocket support implemented by Andreas Guth (andreas.guth@rwth-aachen.de)
 */

/** PrivateConstructor: Strophe.Websocket
 *  Create and initialize a Strophe.WebSocket object.
 *  Currently only sets the connection Object.
 *
 *  Parameters:
 *    (Strophe.Connection) connection - The Strophe.Connection that will use WebSockets.
 *
 *  Returns:
 *    A new Strophe.WebSocket object.
 */

var core = require("./core");

var Strophe = core.Strophe;
var $build = core.$build;

Strophe.Websocket = function(connection) {
  this._conn = connection;
  this.strip = "wrapper";

  var service = connection.service;
  if (service.indexOf("ws:") !== 0 && service.indexOf("wss:") !== 0) {
    // If the service is not an absolute URL, assume it is a path and put the absolute
    // URL together from options, current URL and the path.
    var new_service = "";

    if (
      connection.options.protocol === "ws" &&
      window.location.protocol !== "https:"
    ) {
      new_service += "ws";
    } else {
      new_service += "wss";
    }

    new_service += "://" + window.location.host;

    if (service.indexOf("/") !== 0) {
      new_service += window.location.pathname + service;
    } else {
      new_service += service;
    }

    connection.service = new_service;
  }
};

Strophe.Websocket.prototype = {
  /** PrivateFunction: _buildStream
   *  _Private_ helper function to generate the <stream> start tag for WebSockets
   *
   *  Returns:
   *    A Strophe.Builder with a <stream> element.
   */
  _buildStream: function() {
    return $build("open", {
      xmlns: Strophe.NS.FRAMING,
      to: this._conn.domain,
      version: "1.0"
    });
  },

  /** PrivateFunction: _check_streamerror
   * _Private_ checks a message for stream:error
   *
   *  Parameters:
   *    (Strophe.Request) bodyWrap - The received stanza.
   *    connectstatus - The ConnectStatus that will be set on error.
   *  Returns:
   *     true if there was a streamerror, false otherwise.
   */
  _check_streamerror: function(bodyWrap, connectstatus) {
    var errors;
    if (bodyWrap.getElementsByTagNameNS) {
      errors = bodyWrap.getElementsByTagNameNS(Strophe.NS.STREAM, "error");
    } else {
      errors = bodyWrap.getElementsByTagName("stream:error");
    }
    if (errors.length === 0) {
      return false;
    }
    var error = errors[0];

    var condition = "";
    var text = "";

    var ns = "urn:ietf:params:xml:ns:xmpp-streams";
    for (var i = 0; i < error.childNodes.length; i++) {
      var e = error.childNodes[i];
      if (e.getAttribute("xmlns") !== ns) {
        break;
      }
      if (e.nodeName === "text") {
        text = e.textContent;
      } else {
        condition = e.nodeName;
      }
    }

    var errorString = "WebSocket stream error: ";

    if (condition) {
      errorString += condition;
    } else {
      errorString += "unknown";
    }

    if (text) {
      errorString += " - " + text;
    }

    Strophe.error(errorString);

    // close the connection on stream_error
    this._conn._changeConnectStatus(connectstatus, condition);
    this._conn._doDisconnect();
    return true;
  },

  /** PrivateFunction: _reset
   *  Reset the connection.
   *
   *  This function is called by the reset function of the Strophe Connection.
   *  Is not needed by WebSockets.
   */
  _reset: function() {
    return;
  },

  /** PrivateFunction: _connect
   *  _Private_ function called by Strophe.Connection.connect
   *
   *  Creates a WebSocket for a connection and assigns Callbacks to it.
   *  Does nothing if there already is a WebSocket.
   */
  _connect: function() {
    // Ensure that there is no open WebSocket from a previous Connection.
    this._closeSocket();

    // Create the new WobSocket
    this.socket = new WebSocket(this._conn.service, "xmpp");
    this.socket.onopen = this._onOpen.bind(this);
    this.socket.onerror = this._onError.bind(this);
    this.socket.onclose = this._onClose.bind(this);
    this.socket.onmessage = this._connect_cb_wrapper.bind(this);
  },

  /** PrivateFunction: _connect_cb
   *  _Private_ function called by Strophe.Connection._connect_cb
   *
   * checks for stream:error
   *
   *  Parameters:
   *    (Strophe.Request) bodyWrap - The received stanza.
   */
  _connect_cb: function(bodyWrap) {
    var error = this._check_streamerror(bodyWrap, Strophe.Status.CONNFAIL);
    if (error) {
      return Strophe.Status.CONNFAIL;
    }
  },

  /** PrivateFunction: _handleStreamStart
   * _Private_ function that checks the opening <open /> tag for errors.
   *
   * Disconnects if there is an error and returns false, true otherwise.
   *
   *  Parameters:
   *    (Node) message - Stanza containing the <open /> tag.
   */
  _handleStreamStart: function(message) {
    var error = false;

    // Check for errors in the <open /> tag
    var ns = message.getAttribute("xmlns");
    if (typeof ns !== "string") {
      error = "Missing xmlns in <open />";
    } else if (ns !== Strophe.NS.FRAMING) {
      error = "Wrong xmlns in <open />: " + ns;
    }

    var ver = message.getAttribute("version");
    if (typeof ver !== "string") {
      error = "Missing version in <open />";
    } else if (ver !== "1.0") {
      error = "Wrong version in <open />: " + ver;
    }

    if (error) {
      this._conn._changeConnectStatus(Strophe.Status.CONNFAIL, error);
      this._conn._doDisconnect();
      return false;
    }

    return true;
  },

  /** PrivateFunction: _connect_cb_wrapper
   * _Private_ function that handles the first connection messages.
   *
   * On receiving an opening stream tag this callback replaces itself with the real
   * message handler. On receiving a stream error the connection is terminated.
   */
  _connect_cb_wrapper: function(message) {
    if (
      message.data.indexOf("<open ") === 0 ||
      message.data.indexOf("<?xml") === 0
    ) {
      // Strip the XML Declaration, if there is one
      var data = message.data.replace(/^(<\?.*?\?>\s*)*/, "");
      if (data === "") return;

      var streamStart = new DOMParser().parseFromString(data, "text/xml")
        .documentElement;
      this._conn.xmlInput(streamStart);
      this._conn.rawInput(message.data);

      //_handleStreamSteart will check for XML errors and disconnect on error
      if (this._handleStreamStart(streamStart)) {
        //_connect_cb will check for stream:error and disconnect on error
        this._connect_cb(streamStart);
      }
    } else if (message.data.indexOf("<close ") === 0) {
      // <close xmlns="urn:ietf:params:xml:ns:xmpp-framing />
      this._conn.rawInput(message.data);
      this._conn.xmlInput(message);
      var see_uri = message.getAttribute("see-other-uri");
      if (see_uri) {
        this._conn._changeConnectStatus(
          Strophe.Status.REDIRECT,
          "Received see-other-uri, resetting connection"
        );
        this._conn.reset();
        this._conn.service = see_uri;
        this._connect();
      } else {
        this._conn._changeConnectStatus(
          Strophe.Status.CONNFAIL,
          "Received closing stream"
        );
        this._conn._doDisconnect();
      }
    } else {
      var string = this._streamWrap(message.data);
      var elem = new DOMParser().parseFromString(string, "text/xml")
        .documentElement;
      this.socket.onmessage = this._onMessage.bind(this);
      this._conn._connect_cb(elem, null, message.data);
    }
  },

  /** PrivateFunction: _disconnect
   *  _Private_ function called by Strophe.Connection.disconnect
   *
   *  Disconnects and sends a last stanza if one is given
   *
   *  Parameters:
   *    (Request) pres - This stanza will be sent before disconnecting.
   */
  _disconnect: function(pres) {
    if (this.socket && this.socket.readyState !== WebSocket.CLOSED) {
      if (pres) {
        this._conn.send(pres);
      }
      var close = $build("close", { xmlns: Strophe.NS.FRAMING });
      this._conn.xmlOutput(close.tree());
      var closeString = Strophe.serialize(close);
      this._conn.rawOutput(closeString);
      try {
        this.socket.send(closeString);
      } catch (e) {
        Strophe.info("Couldn't send <close /> tag.");
      }
    }
    this._conn._doDisconnect();
  },

  /** PrivateFunction: _doDisconnect
   *  _Private_ function to disconnect.
   *
   *  Just closes the Socket for WebSockets
   */
  _doDisconnect: function() {
    Strophe.info("WebSockets _doDisconnect was called");
    this._closeSocket();
  },

  /** PrivateFunction _streamWrap
   *  _Private_ helper function to wrap a stanza in a <stream> tag.
   *  This is used so Strophe can process stanzas from WebSockets like BOSH
   */
  _streamWrap: function(stanza) {
    return "<wrapper>" + stanza + "</wrapper>";
  },

  /** PrivateFunction: _closeSocket
   *  _Private_ function to close the WebSocket.
   *
   *  Closes the socket if it is still open and deletes it
   */
  _closeSocket: function() {
    if (this.socket) {
      try {
        this.socket.onerror = null;
        this.socket.close();
      } catch (e) {}
    }
    this.socket = null;
  },

  /** PrivateFunction: _emptyQueue
   * _Private_ function to check if the message queue is empty.
   *
   *  Returns:
   *    True, because WebSocket messages are send immediately after queueing.
   */
  _emptyQueue: function() {
    return true;
  },

  /** PrivateFunction: _onClose
   * _Private_ function to handle websockets closing.
   *
   * Nothing to do here for WebSockets
   */
  _onClose: function(e) {
    if (this._conn.connected && !this._conn.disconnecting) {
      Strophe.error("Websocket closed unexpectedly");
      this._conn._doDisconnect();
    } else if (e && e.code === 1006 && !this._conn.connected && this.socket) {
      // in case the onError callback was not called (Safari 10 does not
      // call onerror when the initial connection fails) we need to
      // dispatch a CONNFAIL status update to be consistent with the
      // behavior on other browsers.
      Strophe.error("Websocket closed unexcectedly");
      this._conn._changeConnectStatus(
        Strophe.Status.CONNFAIL,
        "The WebSocket connection could not be established or was disconnected."
      );
      this._conn._doDisconnect();
    } else {
      Strophe.info("Websocket closed");
    }
  },

  /** PrivateFunction: _onDisconnectTimeout
   *  _Private_ timeout handler for handling non-graceful disconnection.
   *
   *  This does nothing for WebSockets
   */
  _onDisconnectTimeout: function() {},

  /** PrivateFunction: _abortAllRequests
   *  _Private_ helper function that makes sure all pending requests are aborted.
   */
  _abortAllRequests: function() {},

  /** PrivateFunction: _onError
   * _Private_ function to handle websockets errors.
   *
   * Parameters:
   * (Object) error - The websocket error.
   */
  _onError: function(error) {
    Strophe.error("Websocket error " + error);
    this._conn._changeConnectStatus(
      Strophe.Status.CONNFAIL,
      "The WebSocket connection could not be established or was disconnected."
    );
    this._disconnect();
  },

  /** PrivateFunction: _onIdle
   *  _Private_ function called by Strophe.Connection._onIdle
   *
   *  sends all queued stanzas
   */
  _onIdle: function() {
    var data = this._conn._data;
    if (data.length > 0 && !this._conn.paused) {
      for (var i = 0; i < data.length; i++) {
        if (data[i] !== null) {
          var stanza, rawStanza;
          if (data[i] === "restart") {
            stanza = this._buildStream().tree();
          } else {
            stanza = data[i];
          }
          rawStanza = Strophe.serialize(stanza);
          this._conn.xmlOutput(stanza);
          this._conn.rawOutput(rawStanza);
          this.socket.send(rawStanza);
        }
      }
      this._conn._data = [];
    }
  },

  /** PrivateFunction: _onMessage
   * _Private_ function to handle websockets messages.
   *
   * This function parses each of the messages as if they are full documents.
   * [TODO : We may actually want to use a SAX Push parser].
   *
   * Since all XMPP traffic starts with
   *  <stream:stream version='1.0'
   *                 xml:lang='en'
   *                 xmlns='jabber:client'
   *                 xmlns:stream='http://etherx.jabber.org/streams'
   *                 id='3697395463'
   *                 from='SERVER'>
   *
   * The first stanza will always fail to be parsed.
   *
   * Additionally, the seconds stanza will always be <stream:features> with
   * the stream NS defined in the previous stanza, so we need to 'force'
   * the inclusion of the NS in this stanza.
   *
   * Parameters:
   * (string) message - The websocket message.
   */
  _onMessage: function(message) {
    var elem, data;
    // check for closing stream
    var close = '<close xmlns="urn:ietf:params:xml:ns:xmpp-framing" />';
    if (message.data === close) {
      this._conn.rawInput(close);
      this._conn.xmlInput(message);
      if (!this._conn.disconnecting) {
        this._conn._doDisconnect();
      }
      return;
    } else if (message.data.search("<open ") === 0) {
      // This handles stream restarts
      elem = new DOMParser().parseFromString(message.data, "text/xml")
        .documentElement;
      if (!this._handleStreamStart(elem)) {
        return;
      }
    } else {
      data = this._streamWrap(message.data);
      elem = new DOMParser().parseFromString(data, "text/xml").documentElement;
    }

    if (this._check_streamerror(elem, Strophe.Status.ERROR)) {
      return;
    }

    //handle unavailable presence stanza before disconnecting
    if (
      this._conn.disconnecting &&
      elem.firstChild.nodeName === "presence" &&
      elem.firstChild.getAttribute("type") === "unavailable"
    ) {
      this._conn.xmlInput(elem);
      this._conn.rawInput(Strophe.serialize(elem));
      // if we are already disconnecting we will ignore the unavailable stanza and
      // wait for the </stream:stream> tag before we close the connection
      return;
    }
    this._conn._dataRecv(elem, message.data);
  },

  /** PrivateFunction: _onOpen
   * _Private_ function to handle websockets connection setup.
   *
   * The opening stream tag is sent here.
   */
  _onOpen: function() {
    Strophe.info("Websocket open");
    var start = this._buildStream();
    this._conn.xmlOutput(start.tree());

    var startString = Strophe.serialize(start);
    this._conn.rawOutput(startString);
    this.socket.send(startString);
  },

  /** PrivateFunction: _reqToData
   * _Private_ function to get a stanza out of a request.
   *
   * WebSockets don't use requests, so the passed argument is just returned.
   *
   *  Parameters:
   *    (Object) stanza - The stanza.
   *
   *  Returns:
   *    The stanza that was passed.
   */
  _reqToData: function(stanza) {
    return stanza;
  },

  /** PrivateFunction: _send
   *  _Private_ part of the Connection.send function for WebSocket
   *
   * Just flushes the messages that are in the queue
   */
  _send: function() {
    this._conn.flush();
  },

  /** PrivateFunction: _sendRestart
   *
   *  Send an xmpp:restart stanza.
   */
  _sendRestart: function() {
    clearTimeout(this._conn._idleTimeout);
    this._conn._onIdle.bind(this._conn)();
  }
};

module.exports = Strophe;

// return Strophe;
/* jshint undef: true, unused: true:, noarg: true, latedef: true */
/* global define, window, clearTimeout, WebSocket, DOMParser, Strophe, $build */

// (function(root, factory) {
//   if (typeof define === "function" && define.amd) {
//     define(["strophe-core"], function(core) {
//       return factory(core.Strophe, core.$build);
//     });
//   } else if (typeof exports === "object") {
//     var core = require("./core");

//     module.exports = factory(core.Strophe, core.$build);
//   } else {
//     // Browser globals
//     return factory(Strophe, $build);
//   }
// })(this, function(Strophe, $build) {});