You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mina.apache.org by ng...@apache.org on 2010/08/05 22:10:40 UTC
svn commit: r982759 [4/5] - in
/mina/vysper/trunk/server/extensions/xep0124-xep0206-bosh/src:
examples/client/ examples/resources/jquery/ examples/resources/jquery/css/
examples/resources/jquery/css/images/ examples/resources/strophe/
main/java/org/apa...
Added: mina/vysper/trunk/server/extensions/xep0124-xep0206-bosh/src/examples/resources/strophe/core.js
URL: http://svn.apache.org/viewvc/mina/vysper/trunk/server/extensions/xep0124-xep0206-bosh/src/examples/resources/strophe/core.js?rev=982759&view=auto
==============================================================================
--- mina/vysper/trunk/server/extensions/xep0124-xep0206-bosh/src/examples/resources/strophe/core.js (added)
+++ mina/vysper/trunk/server/extensions/xep0124-xep0206-bosh/src/examples/resources/strophe/core.js Thu Aug 5 20:10:39 2010
@@ -0,0 +1,3179 @@
+/*
+ This program is distributed under the terms of the MIT license.
+ Please see the LICENSE file for details.
+
+ Copyright 2006-2008, OGG, LLC
+*/
+
+/* jslint configuration: */
+/*global document, window, setTimeout, clearTimeout, console,
+ XMLHttpRequest, ActiveXObject,
+ Base64, MD5,
+ Strophe, $build, $msg, $iq, $pres */
+
+/** File: strophe.js
+ * A JavaScript library for XMPP BOSH.
+ *
+ * This is the JavaScript version of the Strophe library. Since JavaScript
+ * has no facilities for persistent TCP connections, this library uses
+ * Bidirectional-streams Over Synchronous HTTP (BOSH) to emulate
+ * a persistent, stateful, two-way connection to an XMPP server. More
+ * information on BOSH can be found in XEP 124.
+ */
+
+/** PrivateFunction: Function.prototype.bind
+ * Bind a function to an instance.
+ *
+ * This Function object extension method creates a bound method similar
+ * to those in Python. This means that the 'this' object will point
+ * to the instance you want. See
+ * <a href='http://benjamin.smedbergs.us/blog/2007-01-03/bound-functions-and-function-imports-in-javascript/'>Bound Functions and Function Imports in JavaScript</a>
+ * for a complete explanation.
+ *
+ * This extension already exists in some browsers (namely, Firefox 3), but
+ * we provide it to support those that don't.
+ *
+ * Parameters:
+ * (Object) obj - The object that will become 'this' in the bound function.
+ *
+ * Returns:
+ * The bound function.
+ */
+if (!Function.prototype.bind) {
+ Function.prototype.bind = function (obj)
+ {
+ var func = this;
+ return function () { return func.apply(obj, arguments); };
+ };
+}
+
+/** PrivateFunction: Function.prototype.prependArg
+ * Prepend an argument to a function.
+ *
+ * This Function object extension method returns a Function that will
+ * invoke the original function with an argument prepended. This is useful
+ * when some object has a callback that needs to get that same object as
+ * an argument. The following fragment illustrates a simple case of this
+ * > var obj = new Foo(this.someMethod);</code></blockquote>
+ *
+ * Foo's constructor can now use func.prependArg(this) to ensure the
+ * passed in callback function gets the instance of Foo as an argument.
+ * Doing this without prependArg would mean not setting the callback
+ * from the constructor.
+ *
+ * This is used inside Strophe for passing the Strophe.Request object to
+ * the onreadystatechange handler of XMLHttpRequests.
+ *
+ * Parameters:
+ * arg - The argument to pass as the first parameter to the function.
+ *
+ * Returns:
+ * A new Function which calls the original with the prepended argument.
+ */
+if (!Function.prototype.prependArg) {
+ Function.prototype.prependArg = function (arg)
+ {
+ var func = this;
+
+ return function () {
+ var newargs = [arg];
+ for (var i = 0; i < arguments.length; i++) {
+ newargs.push(arguments[i]);
+ }
+ return func.apply(this, newargs);
+ };
+ };
+}
+
+/** PrivateFunction: Array.prototype.indexOf
+ * Return the index of an object in an array.
+ *
+ * This function is not supplied by some JavaScript implementations, so
+ * we provide it if it is missing. This code is from:
+ * http://developer.mozilla.org/En/Core_JavaScript_1.5_Reference:Objects:Array:indexOf
+ *
+ * Parameters:
+ * (Object) elt - The object to look for.
+ * (Integer) from - The index from which to start looking. (optional).
+ *
+ * Returns:
+ * The index of elt in the array or -1 if not found.
+ */
+if (!Array.prototype.indexOf)
+{
+ Array.prototype.indexOf = function(elt /*, from*/)
+ {
+ var len = this.length;
+
+ var from = Number(arguments[1]) || 0;
+ from = (from < 0) ? Math.ceil(from) : Math.floor(from);
+ if (from < 0) {
+ from += len;
+ }
+
+ for (; from < len; from++) {
+ if (from in this && this[from] === elt) {
+ return from;
+ }
+ }
+
+ return -1;
+ };
+}
+
+/* All of the Strophe globals are defined in this special function below so
+ * that references to the globals become closures. This will ensure that
+ * on page reload, these references will still be available to callbacks
+ * that are still executing.
+ */
+
+(function (callback) {
+var Strophe;
+
+/** Function: $build
+ * Create a Strophe.Builder.
+ * This is an alias for 'new Strophe.Builder(name, attrs)'.
+ *
+ * Parameters:
+ * (String) name - The root element name.
+ * (Object) attrs - The attributes for the root element in object notation.
+ *
+ * Returns:
+ * A new Strophe.Builder object.
+ */
+function $build(name, attrs) { return new Strophe.Builder(name, attrs); }
+/** Function: $msg
+ * Create a Strophe.Builder with a <message/> element as the root.
+ *
+ * Parmaeters:
+ * (Object) attrs - The <message/> element attributes in object notation.
+ *
+ * Returns:
+ * A new Strophe.Builder object.
+ */
+function $msg(attrs) { return new Strophe.Builder("message", attrs); }
+/** Function: $iq
+ * Create a Strophe.Builder with an <iq/> element as the root.
+ *
+ * Parameters:
+ * (Object) attrs - The <iq/> element attributes in object notation.
+ *
+ * Returns:
+ * A new Strophe.Builder object.
+ */
+function $iq(attrs) { return new Strophe.Builder("iq", attrs); }
+/** Function: $pres
+ * Create a Strophe.Builder with a <presence/> element as the root.
+ *
+ * Parameters:
+ * (Object) attrs - The <presence/> element attributes in object notation.
+ *
+ * Returns:
+ * A new Strophe.Builder object.
+ */
+function $pres(attrs) { return new Strophe.Builder("presence", attrs); }
+
+/** Class: Strophe
+ * An object container for all Strophe library functions.
+ *
+ * This class is just a container for all the objects and constants
+ * used in the library. It is not meant to be instantiated, but to
+ * provide a namespace for library objects, constants, and functions.
+ */
+Strophe = {
+ /** Constant: VERSION
+ * The version of the Strophe library. Unreleased builds will have
+ * a version of head-HASH where HASH is a partial revision.
+ */
+ VERSION: "@VERSION@",
+
+ /** Constants: XMPP Namespace Constants
+ * Common namespace constants from the XMPP RFCs and XEPs.
+ *
+ * NS.HTTPBIND - HTTP BIND namespace from XEP 124.
+ * NS.BOSH - BOSH namespace from XEP 206.
+ * NS.CLIENT - Main XMPP client namespace.
+ * NS.AUTH - Legacy authentication namespace.
+ * NS.ROSTER - Roster operations namespace.
+ * NS.PROFILE - Profile namespace.
+ * NS.DISCO_INFO - Service discovery info namespace from XEP 30.
+ * NS.DISCO_ITEMS - Service discovery items namespace from XEP 30.
+ * NS.MUC - Multi-User Chat namespace from XEP 45.
+ * NS.SASL - XMPP SASL namespace from RFC 3920.
+ * NS.STREAM - XMPP Streams namespace from RFC 3920.
+ * NS.BIND - XMPP Binding namespace from RFC 3920.
+ * NS.SESSION - XMPP Session namespace from RFC 3920.
+ */
+ NS: {
+ HTTPBIND: "http://jabber.org/protocol/httpbind",
+ BOSH: "urn:xmpp:xbosh",
+ CLIENT: "jabber:client",
+ AUTH: "jabber:iq:auth",
+ ROSTER: "jabber:iq:roster",
+ PROFILE: "jabber:iq:profile",
+ DISCO_INFO: "http://jabber.org/protocol/disco#info",
+ DISCO_ITEMS: "http://jabber.org/protocol/disco#items",
+ MUC: "http://jabber.org/protocol/muc",
+ SASL: "urn:ietf:params:xml:ns:xmpp-sasl",
+ STREAM: "http://etherx.jabber.org/streams",
+ BIND: "urn:ietf:params:xml:ns:xmpp-bind",
+ SESSION: "urn:ietf:params:xml:ns:xmpp-session",
+ VERSION: "jabber:iq:version",
+ STANZAS: "urn:ietf:params:xml:ns:xmpp-stanzas"
+ },
+
+ /** Function: addNamespace
+ * This function is used to extend the current namespaces in
+ * Strophe.NS. It takes a key and a value with the key being the
+ * name of the new namespace, with its actual value.
+ * For example:
+ * Strophe.addNamespace('PUBSUB', "http://jabber.org/protocol/pubsub");
+ *
+ * Parameters:
+ * (String) name - The name under which the namespace will be
+ * referenced under Strophe.NS
+ * (String) value - The actual namespace.
+ */
+ addNamespace: function (name, value)
+ {
+ Strophe.NS[name] = value;
+ },
+
+ /** Constants: Connection Status Constants
+ * Connection status constants for use by the connection handler
+ * callback.
+ *
+ * Status.ERROR - An error has occurred
+ * Status.CONNECTING - The connection is currently being made
+ * Status.CONNFAIL - The connection attempt failed
+ * Status.AUTHENTICATING - The connection is authenticating
+ * Status.AUTHFAIL - The authentication attempt failed
+ * Status.CONNECTED - The connection has succeeded
+ * Status.DISCONNECTED - The connection has been terminated
+ * Status.DISCONNECTING - The connection is currently being terminated
+ * Status.ATTACHED - The connection has been attached
+ */
+ Status: {
+ ERROR: 0,
+ CONNECTING: 1,
+ CONNFAIL: 2,
+ AUTHENTICATING: 3,
+ AUTHFAIL: 4,
+ CONNECTED: 5,
+ DISCONNECTED: 6,
+ DISCONNECTING: 7,
+ ATTACHED: 8
+ },
+
+ /** Constants: Log Level Constants
+ * Logging level indicators.
+ *
+ * LogLevel.DEBUG - Debug output
+ * LogLevel.INFO - Informational output
+ * LogLevel.WARN - Warnings
+ * LogLevel.ERROR - Errors
+ * LogLevel.FATAL - Fatal errors
+ */
+ LogLevel: {
+ DEBUG: 0,
+ INFO: 1,
+ WARN: 2,
+ ERROR: 3,
+ FATAL: 4
+ },
+
+ /** PrivateConstants: DOM Element Type Constants
+ * DOM element types.
+ *
+ * ElementType.NORMAL - Normal element.
+ * ElementType.TEXT - Text data element.
+ */
+ ElementType: {
+ NORMAL: 1,
+ TEXT: 3
+ },
+
+ /** PrivateConstants: Timeout Values
+ * Timeout values for error states. These values are in seconds.
+ * These should not be changed unless you know exactly what you are
+ * doing.
+ *
+ * TIMEOUT - Timeout multiplier. A waiting request will be considered
+ * failed after Math.floor(TIMEOUT * wait) seconds have elapsed.
+ * This defaults to 1.1, and with default wait, 66 seconds.
+ * SECONDARY_TIMEOUT - Secondary timeout multiplier. In cases where
+ * Strophe can detect early failure, it will consider the request
+ * failed if it doesn't return after
+ * Math.floor(SECONDARY_TIMEOUT * wait) seconds have elapsed.
+ * This defaults to 0.1, and with default wait, 6 seconds.
+ */
+ TIMEOUT: 1.1,
+ SECONDARY_TIMEOUT: 0.1,
+
+ /** Function: forEachChild
+ * Map a function over some or all child elements of a given element.
+ *
+ * This is a small convenience function for mapping a function over
+ * some or all of the children of an element. If elemName is null, all
+ * children will be passed to the function, otherwise only children
+ * whose tag names match elemName will be passed.
+ *
+ * Parameters:
+ * (XMLElement) elem - The element to operate on.
+ * (String) elemName - The child element tag name filter.
+ * (Function) func - The function to apply to each child. This
+ * function should take a single argument, a DOM element.
+ */
+ forEachChild: function (elem, elemName, func)
+ {
+ var i, childNode;
+
+ for (i = 0; i < elem.childNodes.length; i++) {
+ childNode = elem.childNodes[i];
+ if (childNode.nodeType == Strophe.ElementType.NORMAL &&
+ (!elemName || this.isTagEqual(childNode, elemName))) {
+ func(childNode);
+ }
+ }
+ },
+
+ /** Function: isTagEqual
+ * Compare an element's tag name with a string.
+ *
+ * This function is case insensitive.
+ *
+ * Parameters:
+ * (XMLElement) el - A DOM element.
+ * (String) name - The element name.
+ *
+ * Returns:
+ * true if the element's tag name matches _el_, and false
+ * otherwise.
+ */
+ isTagEqual: function (el, name)
+ {
+ return el.tagName.toLowerCase() == name.toLowerCase();
+ },
+
+ /** PrivateVariable: _xmlGenerator
+ * _Private_ variable that caches a DOM document to
+ * generate elements.
+ */
+ _xmlGenerator: null,
+
+ /** PrivateFunction: _makeGenerator
+ * _Private_ function that creates a dummy XML DOM document to serve as
+ * an element and text node generator.
+ */
+ _makeGenerator: function () {
+ var doc;
+
+ if (window.ActiveXObject) {
+ doc = new ActiveXObject("Microsoft.XMLDOM");
+ doc.appendChild(doc.createElement('strophe'));
+ } else {
+ doc = document.implementation
+ .createDocument('jabber:client', 'strophe', null);
+ }
+
+ return doc;
+ },
+
+ /** Function: xmlElement
+ * Create an XML DOM element.
+ *
+ * This function creates an XML DOM element correctly across all
+ * implementations. Note that these are not HTML DOM elements, which
+ * aren't appropriate for XMPP stanzas.
+ *
+ * Parameters:
+ * (String) name - The name for the element.
+ * (Array|Object) attrs - An optional array or object containing
+ * key/value pairs to use as element attributes. The object should
+ * be in the format {'key': 'value'} or {key: 'value'}. The array
+ * should have the format [['key1', 'value1'], ['key2', 'value2']].
+ * (String) text - The text child data for the element.
+ *
+ * Returns:
+ * A new XML DOM element.
+ */
+ xmlElement: function (name)
+ {
+ if (!name) { return null; }
+
+ var node = null;
+ if (!Strophe._xmlGenerator) {
+ Strophe._xmlGenerator = Strophe._makeGenerator();
+ }
+ node = Strophe._xmlGenerator.createElement(name);
+
+ // FIXME: this should throw errors if args are the wrong type or
+ // there are more than two optional args
+ var a, i, k;
+ for (a = 1; a < arguments.length; a++) {
+ if (!arguments[a]) { continue; }
+ if (typeof(arguments[a]) == "string" ||
+ typeof(arguments[a]) == "number") {
+ node.appendChild(Strophe.xmlTextNode(arguments[a]));
+ } else if (typeof(arguments[a]) == "object" &&
+ typeof(arguments[a].sort) == "function") {
+ for (i = 0; i < arguments[a].length; i++) {
+ if (typeof(arguments[a][i]) == "object" &&
+ typeof(arguments[a][i].sort) == "function") {
+ node.setAttribute(arguments[a][i][0],
+ arguments[a][i][1]);
+ }
+ }
+ } else if (typeof(arguments[a]) == "object") {
+ for (k in arguments[a]) {
+ if (arguments[a].hasOwnProperty(k)) {
+ node.setAttribute(k, arguments[a][k]);
+ }
+ }
+ }
+ }
+
+ return node;
+ },
+
+ /* Function: xmlescape
+ * Excapes invalid xml characters.
+ *
+ * Parameters:
+ * (String) text - text to escape.
+ *
+ * Returns:
+ * Escaped text.
+ */
+ xmlescape: function(text)
+ {
+ text = text.replace(/\&/g, "&");
+ text = text.replace(/</g, "<");
+ text = text.replace(/>/g, ">");
+ return text;
+ },
+
+ /** Function: xmlTextNode
+ * Creates an XML DOM text node.
+ *
+ * Provides a cross implementation version of document.createTextNode.
+ *
+ * Parameters:
+ * (String) text - The content of the text node.
+ *
+ * Returns:
+ * A new XML DOM text node.
+ */
+ xmlTextNode: function (text)
+ {
+ //ensure text is escaped
+ text = Strophe.xmlescape(text);
+
+ if (!Strophe._xmlGenerator) {
+ Strophe._xmlGenerator = Strophe._makeGenerator();
+ }
+ return Strophe._xmlGenerator.createTextNode(text);
+ },
+
+ /** Function: getText
+ * Get the concatenation of all text children of an element.
+ *
+ * Parameters:
+ * (XMLElement) elem - A DOM element.
+ *
+ * Returns:
+ * A String with the concatenated text of all text element children.
+ */
+ getText: function (elem)
+ {
+ if (!elem) { return null; }
+
+ var str = "";
+ if (elem.childNodes.length === 0 && elem.nodeType ==
+ Strophe.ElementType.TEXT) {
+ str += elem.nodeValue;
+ }
+
+ for (var i = 0; i < elem.childNodes.length; i++) {
+ if (elem.childNodes[i].nodeType == Strophe.ElementType.TEXT) {
+ str += elem.childNodes[i].nodeValue;
+ }
+ }
+
+ return str;
+ },
+
+ /** Function: copyElement
+ * Copy an XML DOM element.
+ *
+ * This function copies a DOM element and all its descendants and returns
+ * the new copy.
+ *
+ * Parameters:
+ * (XMLElement) elem - A DOM element.
+ *
+ * Returns:
+ * A new, copied DOM element tree.
+ */
+ copyElement: function (elem)
+ {
+ var i, el;
+ if (elem.nodeType == Strophe.ElementType.NORMAL) {
+ el = Strophe.xmlElement(elem.tagName);
+
+ for (i = 0; i < elem.attributes.length; i++) {
+ el.setAttribute(elem.attributes[i].nodeName.toLowerCase(),
+ elem.attributes[i].value);
+ }
+
+ for (i = 0; i < elem.childNodes.length; i++) {
+ el.appendChild(Strophe.copyElement(elem.childNodes[i]));
+ }
+ } else if (elem.nodeType == Strophe.ElementType.TEXT) {
+ el = Strophe.xmlTextNode(elem.nodeValue);
+ }
+
+ return el;
+ },
+
+ /** Function: escapeNode
+ * Escape the node part (also called local part) of a JID.
+ *
+ * Parameters:
+ * (String) node - A node (or local part).
+ *
+ * Returns:
+ * An escaped node (or local part).
+ */
+ escapeNode: function (node)
+ {
+ return node.replace(/^\s+|\s+$/g, '')
+ .replace(/\\/g, "\\5c")
+ .replace(/ /g, "\\20")
+ .replace(/\"/g, "\\22")
+ .replace(/\&/g, "\\26")
+ .replace(/\'/g, "\\27")
+ .replace(/\//g, "\\2f")
+ .replace(/:/g, "\\3a")
+ .replace(/</g, "\\3c")
+ .replace(/>/g, "\\3e")
+ .replace(/@/g, "\\40");
+ },
+
+ /** Function: unescapeNode
+ * Unescape a node part (also called local part) of a JID.
+ *
+ * Parameters:
+ * (String) node - A node (or local part).
+ *
+ * Returns:
+ * An unescaped node (or local part).
+ */
+ unescapeNode: function (node)
+ {
+ return node.replace(/\\20/g, " ")
+ .replace(/\\22/g, '"')
+ .replace(/\\26/g, "&")
+ .replace(/\\27/g, "'")
+ .replace(/\\2f/g, "/")
+ .replace(/\\3a/g, ":")
+ .replace(/\\3c/g, "<")
+ .replace(/\\3e/g, ">")
+ .replace(/\\40/g, "@")
+ .replace(/\\5c/g, "\\");
+ },
+
+ /** Function: getNodeFromJid
+ * Get the node portion of a JID String.
+ *
+ * Parameters:
+ * (String) jid - A JID.
+ *
+ * Returns:
+ * A String containing the node.
+ */
+ getNodeFromJid: function (jid)
+ {
+ if (jid.indexOf("@") < 0) { return null; }
+ return jid.split("@")[0];
+ },
+
+ /** Function: getDomainFromJid
+ * Get the domain portion of a JID String.
+ *
+ * Parameters:
+ * (String) jid - A JID.
+ *
+ * Returns:
+ * A String containing the domain.
+ */
+ getDomainFromJid: function (jid)
+ {
+ var bare = Strophe.getBareJidFromJid(jid);
+ if (bare.indexOf("@") < 0) {
+ return bare;
+ } else {
+ var parts = bare.split("@");
+ parts.splice(0, 1);
+ return parts.join('@');
+ }
+ },
+
+ /** Function: getResourceFromJid
+ * Get the resource portion of a JID String.
+ *
+ * Parameters:
+ * (String) jid - A JID.
+ *
+ * Returns:
+ * A String containing the resource.
+ */
+ getResourceFromJid: function (jid)
+ {
+ var s = jid.split("/");
+ if (s.length < 2) { return null; }
+ s.splice(0, 1);
+ return s.join('/');
+ },
+
+ /** Function: getBareJidFromJid
+ * Get the bare JID from a JID String.
+ *
+ * Parameters:
+ * (String) jid - A JID.
+ *
+ * Returns:
+ * A String containing the bare JID.
+ */
+ getBareJidFromJid: function (jid)
+ {
+ return jid ? jid.split("/")[0] : null;
+ },
+
+ /** Function: log
+ * User overrideable logging function.
+ *
+ * This function is called whenever the Strophe library calls any
+ * of the logging functions. The default implementation of this
+ * function does nothing. If client code wishes to handle the logging
+ * messages, it should override this with
+ * > Strophe.log = function (level, msg) {
+ * > (user code here)
+ * > };
+ *
+ * Please note that data sent and received over the wire is logged
+ * via Strophe.Connection.rawInput() and Strophe.Connection.rawOutput().
+ *
+ * The different levels and their meanings are
+ *
+ * DEBUG - Messages useful for debugging purposes.
+ * INFO - Informational messages. This is mostly information like
+ * 'disconnect was called' or 'SASL auth succeeded'.
+ * WARN - Warnings about potential problems. This is mostly used
+ * to report transient connection errors like request timeouts.
+ * ERROR - Some error occurred.
+ * FATAL - A non-recoverable fatal error occurred.
+ *
+ * Parameters:
+ * (Integer) level - The log level of the log message. This will
+ * be one of the values in Strophe.LogLevel.
+ * (String) msg - The log message.
+ */
+ log: function (level, msg)
+ {
+ return;
+ },
+
+ /** Function: debug
+ * Log a message at the Strophe.LogLevel.DEBUG level.
+ *
+ * Parameters:
+ * (String) msg - The log message.
+ */
+ debug: function(msg)
+ {
+ this.log(this.LogLevel.DEBUG, msg);
+ },
+
+ /** Function: info
+ * Log a message at the Strophe.LogLevel.INFO level.
+ *
+ * Parameters:
+ * (String) msg - The log message.
+ */
+ info: function (msg)
+ {
+ this.log(this.LogLevel.INFO, msg);
+ },
+
+ /** Function: warn
+ * Log a message at the Strophe.LogLevel.WARN level.
+ *
+ * Parameters:
+ * (String) msg - The log message.
+ */
+ warn: function (msg)
+ {
+ this.log(this.LogLevel.WARN, msg);
+ },
+
+ /** Function: error
+ * Log a message at the Strophe.LogLevel.ERROR level.
+ *
+ * Parameters:
+ * (String) msg - The log message.
+ */
+ error: function (msg)
+ {
+ this.log(this.LogLevel.ERROR, msg);
+ },
+
+ /** Function: fatal
+ * Log a message at the Strophe.LogLevel.FATAL level.
+ *
+ * Parameters:
+ * (String) msg - The log message.
+ */
+ fatal: function (msg)
+ {
+ this.log(this.LogLevel.FATAL, msg);
+ },
+
+ /** Function: serialize
+ * Render a DOM element and all descendants to a String.
+ *
+ * Parameters:
+ * (XMLElement) elem - A DOM element.
+ *
+ * Returns:
+ * The serialized element tree as a String.
+ */
+ serialize: function (elem)
+ {
+ var result;
+
+ if (!elem) { return null; }
+
+ if (typeof(elem.tree) === "function") {
+ elem = elem.tree();
+ }
+
+ var nodeName = elem.nodeName;
+ var i, child;
+
+ if (elem.getAttribute("_realname")) {
+ nodeName = elem.getAttribute("_realname");
+ }
+
+ result = "<" + nodeName;
+ for (i = 0; i < elem.attributes.length; i++) {
+ if(elem.attributes[i].nodeName != "_realname") {
+ result += " " + elem.attributes[i].nodeName.toLowerCase() +
+ "='" + elem.attributes[i].value
+ .replace("&", "&")
+ .replace("'", "'")
+ .replace("<", "<") + "'";
+ }
+ }
+
+ if (elem.childNodes.length > 0) {
+ result += ">";
+ for (i = 0; i < elem.childNodes.length; i++) {
+ child = elem.childNodes[i];
+ if (child.nodeType == Strophe.ElementType.NORMAL) {
+ // normal element, so recurse
+ result += Strophe.serialize(child);
+ } else if (child.nodeType == Strophe.ElementType.TEXT) {
+ // text element
+ result += child.nodeValue;
+ }
+ }
+ result += "</" + nodeName + ">";
+ } else {
+ result += "/>";
+ }
+
+ return result;
+ },
+
+ /** PrivateVariable: _requestId
+ * _Private_ variable that keeps track of the request ids for
+ * connections.
+ */
+ _requestId: 0,
+
+ /** PrivateVariable: Strophe.connectionPlugins
+ * _Private_ variable Used to store plugin names that need
+ * initialization on Strophe.Connection construction.
+ */
+ _connectionPlugins: {},
+
+ /** Function: addConnectionPlugin
+ * Extends the Strophe.Connection object with the given plugin.
+ *
+ * Paramaters:
+ * (String) name - The name of the extension.
+ * (Object) ptype - The plugin's prototype.
+ */
+ addConnectionPlugin: function (name, ptype)
+ {
+ Strophe._connectionPlugins[name] = ptype;
+ }
+};
+
+/** Class: Strophe.Builder
+ * XML DOM builder.
+ *
+ * This object provides an interface similar to JQuery but for building
+ * DOM element easily and rapidly. All the functions except for toString()
+ * and tree() return the object, so calls can be chained. Here's an
+ * example using the $iq() builder helper.
+ * > $iq({to: 'you', from: 'me', type: 'get', id: '1'})
+ * > .c('query', {xmlns: 'strophe:example'})
+ * > .c('example')
+ * > .toString()
+ * The above generates this XML fragment
+ * > <iq to='you' from='me' type='get' id='1'>
+ * > <query xmlns='strophe:example'>
+ * > <example/>
+ * > </query>
+ * > </iq>
+ * The corresponding DOM manipulations to get a similar fragment would be
+ * a lot more tedious and probably involve several helper variables.
+ *
+ * Since adding children makes new operations operate on the child, up()
+ * is provided to traverse up the tree. To add two children, do
+ * > builder.c('child1', ...).up().c('child2', ...)
+ * The next operation on the Builder will be relative to the second child.
+ */
+
+/** Constructor: Strophe.Builder
+ * Create a Strophe.Builder object.
+ *
+ * The attributes should be passed in object notation. For example
+ * > var b = new Builder('message', {to: 'you', from: 'me'});
+ * or
+ * > var b = new Builder('messsage', {'xml:lang': 'en'});
+ *
+ * Parameters:
+ * (String) name - The name of the root element.
+ * (Object) attrs - The attributes for the root element in object notation.
+ *
+ * Returns:
+ * A new Strophe.Builder.
+ */
+Strophe.Builder = function (name, attrs)
+{
+ // Set correct namespace for jabber:client elements
+ if (name == "presence" || name == "message" || name == "iq") {
+ if (attrs && !attrs.xmlns) {
+ attrs.xmlns = Strophe.NS.CLIENT;
+ } else if (!attrs) {
+ attrs = {xmlns: Strophe.NS.CLIENT};
+ }
+ }
+
+ // Holds the tree being built.
+ this.nodeTree = Strophe.xmlElement(name, attrs);
+
+ // Points to the current operation node.
+ this.node = this.nodeTree;
+};
+
+Strophe.Builder.prototype = {
+ /** Function: tree
+ * Return the DOM tree.
+ *
+ * This function returns the current DOM tree as an element object. This
+ * is suitable for passing to functions like Strophe.Connection.send().
+ *
+ * Returns:
+ * The DOM tree as a element object.
+ */
+ tree: function ()
+ {
+ return this.nodeTree;
+ },
+
+ /** Function: toString
+ * Serialize the DOM tree to a String.
+ *
+ * This function returns a string serialization of the current DOM
+ * tree. It is often used internally to pass data to a
+ * Strophe.Request object.
+ *
+ * Returns:
+ * The serialized DOM tree in a String.
+ */
+ toString: function ()
+ {
+ return Strophe.serialize(this.nodeTree);
+ },
+
+ /** Function: up
+ * Make the current parent element the new current element.
+ *
+ * This function is often used after c() to traverse back up the tree.
+ * For example, to add two children to the same element
+ * > builder.c('child1', {}).up().c('child2', {});
+ *
+ * Returns:
+ * The Stophe.Builder object.
+ */
+ up: function ()
+ {
+ this.node = this.node.parentNode;
+ return this;
+ },
+
+ /** Function: attrs
+ * Add or modify attributes of the current element.
+ *
+ * The attributes should be passed in object notation. This function
+ * does not move the current element pointer.
+ *
+ * Parameters:
+ * (Object) moreattrs - The attributes to add/modify in object notation.
+ *
+ * Returns:
+ * The Strophe.Builder object.
+ */
+ attrs: function (moreattrs)
+ {
+ for (var k in moreattrs) {
+ if (moreattrs.hasOwnProperty(k)) {
+ this.node.setAttribute(k, moreattrs[k]);
+ }
+ }
+ return this;
+ },
+
+ /** Function: c
+ * Add a child to the current element and make it the new current
+ * element.
+ *
+ * This function moves the current element pointer to the child. If you
+ * need to add another child, it is necessary to use up() to go back
+ * to the parent in the tree.
+ *
+ * Parameters:
+ * (String) name - The name of the child.
+ * (Object) attrs - The attributes of the child in object notation.
+ *
+ * Returns:
+ * The Strophe.Builder object.
+ */
+ c: function (name, attrs)
+ {
+ var child = Strophe.xmlElement(name, attrs);
+ this.node.appendChild(child);
+ this.node = child;
+ return this;
+ },
+
+ /** Function: cnode
+ * Add a child to the current element and make it the new current
+ * element.
+ *
+ * This function is the same as c() except that instead of using a
+ * name and an attributes object to create the child it uses an
+ * existing DOM element object.
+ *
+ * Parameters:
+ * (XMLElement) elem - A DOM element.
+ *
+ * Returns:
+ * The Strophe.Builder object.
+ */
+ cnode: function (elem)
+ {
+ this.node.appendChild(elem);
+ this.node = elem;
+ return this;
+ },
+
+ /** Function: t
+ * Add a child text element.
+ *
+ * This *does not* make the child the new current element since there
+ * are no children of text elements.
+ *
+ * Parameters:
+ * (String) text - The text data to append to the current element.
+ *
+ * Returns:
+ * The Strophe.Builder object.
+ */
+ t: function (text)
+ {
+ var child = Strophe.xmlTextNode(text);
+ this.node.appendChild(child);
+ return this;
+ }
+};
+
+
+/** PrivateClass: Strophe.Handler
+ * _Private_ helper class for managing stanza handlers.
+ *
+ * A Strophe.Handler encapsulates a user provided callback function to be
+ * executed when matching stanzas are received by the connection.
+ * Handlers can be either one-off or persistant depending on their
+ * return value. Returning true will cause a Handler to remain active, and
+ * returning false will remove the Handler.
+ *
+ * Users will not use Strophe.Handler objects directly, but instead they
+ * will use Strophe.Connection.addHandler() and
+ * Strophe.Connection.deleteHandler().
+ */
+
+/** PrivateConstructor: Strophe.Handler
+ * Create and initialize a new Strophe.Handler.
+ *
+ * Parameters:
+ * (Function) handler - A function to be executed when the handler is run.
+ * (String) ns - The namespace to match.
+ * (String) name - The element name to match.
+ * (String) type - The element type to match.
+ * (String) id - The element id attribute to match.
+ * (String) from - The element from attribute to match.
+ * (Object) options - Handler options
+ *
+ * Returns:
+ * A new Strophe.Handler object.
+ */
+Strophe.Handler = function (handler, ns, name, type, id, from, options)
+{
+ this.handler = handler;
+ this.ns = ns;
+ this.name = name;
+ this.type = type;
+ this.id = id;
+ this.options = options || {matchbare: false};
+
+ // default matchBare to false if undefined
+ if (!this.options.matchBare) {
+ this.options.matchBare = false;
+ }
+
+ if (this.options.matchBare) {
+ this.from = from ? Strophe.getBareJidFromJid(from) : null;
+ } else {
+ this.from = from;
+ }
+
+ // whether the handler is a user handler or a system handler
+ this.user = true;
+};
+
+Strophe.Handler.prototype = {
+ /** PrivateFunction: isMatch
+ * Tests if a stanza matches the Strophe.Handler.
+ *
+ * Parameters:
+ * (XMLElement) elem - The XML element to test.
+ *
+ * Returns:
+ * true if the stanza matches and false otherwise.
+ */
+ isMatch: function (elem)
+ {
+ var nsMatch;
+ var from = null;
+
+ if (this.options.matchBare) {
+ from = Strophe.getBareJidFromJid(elem.getAttribute('from'));
+ } else {
+ from = elem.getAttribute('from');
+ }
+
+ nsMatch = false;
+ if (!this.ns) {
+ nsMatch = true;
+ } else {
+ var that = this;
+ Strophe.forEachChild(elem, null, function (elem) {
+ if (elem.getAttribute("xmlns") == that.ns) {
+ nsMatch = true;
+ }
+ });
+
+ nsMatch = nsMatch || elem.getAttribute("xmlns") == this.ns;
+ }
+
+ if (nsMatch &&
+ (!this.name || Strophe.isTagEqual(elem, this.name)) &&
+ (!this.type || elem.getAttribute("type") == this.type) &&
+ (!this.id || elem.getAttribute("id") == this.id) &&
+ (!this.from || from == this.from)) {
+ return true;
+ }
+
+ return false;
+ },
+
+ /** PrivateFunction: run
+ * Run the callback on a matching stanza.
+ *
+ * Parameters:
+ * (XMLElement) elem - The DOM element that triggered the
+ * Strophe.Handler.
+ *
+ * Returns:
+ * A boolean indicating if the handler should remain active.
+ */
+ run: function (elem)
+ {
+ var result = null;
+ try {
+ result = this.handler(elem);
+ } catch (e) {
+ if (e.sourceURL) {
+ Strophe.fatal("error: " + this.handler +
+ " " + e.sourceURL + ":" +
+ e.line + " - " + e.name + ": " + e.message);
+ } else if (e.fileName) {
+ if (typeof(console) != "undefined") {
+ console.trace();
+ console.error(this.handler, " - error - ", e, e.message);
+ }
+ Strophe.fatal("error: " + this.handler + " " +
+ e.fileName + ":" + e.lineNumber + " - " +
+ e.name + ": " + e.message);
+ } else {
+ Strophe.fatal("error: " + this.handler);
+ }
+
+ throw e;
+ }
+
+ return result;
+ },
+
+ /** PrivateFunction: toString
+ * Get a String representation of the Strophe.Handler object.
+ *
+ * Returns:
+ * A String.
+ */
+ toString: function ()
+ {
+ return "{Handler: " + this.handler + "(" + this.name + "," +
+ this.id + "," + this.ns + ")}";
+ }
+};
+
+/** PrivateClass: Strophe.TimedHandler
+ * _Private_ helper class for managing timed handlers.
+ *
+ * A Strophe.TimedHandler encapsulates a user provided callback that
+ * should be called after a certain period of time or at regular
+ * intervals. The return value of the callback determines whether the
+ * Strophe.TimedHandler will continue to fire.
+ *
+ * Users will not use Strophe.TimedHandler objects directly, but instead
+ * they will use Strophe.Connection.addTimedHandler() and
+ * Strophe.Connection.deleteTimedHandler().
+ */
+
+/** PrivateConstructor: Strophe.TimedHandler
+ * Create and initialize a new Strophe.TimedHandler object.
+ *
+ * Parameters:
+ * (Integer) period - The number of milliseconds to wait before the
+ * handler is called.
+ * (Function) handler - The callback to run when the handler fires. This
+ * function should take no arguments.
+ *
+ * Returns:
+ * A new Strophe.TimedHandler object.
+ */
+Strophe.TimedHandler = function (period, handler)
+{
+ this.period = period;
+ this.handler = handler;
+
+ this.lastCalled = new Date().getTime();
+ this.user = true;
+};
+
+Strophe.TimedHandler.prototype = {
+ /** PrivateFunction: run
+ * Run the callback for the Strophe.TimedHandler.
+ *
+ * Returns:
+ * true if the Strophe.TimedHandler should be called again, and false
+ * otherwise.
+ */
+ run: function ()
+ {
+ this.lastCalled = new Date().getTime();
+ return this.handler();
+ },
+
+ /** PrivateFunction: reset
+ * Reset the last called time for the Strophe.TimedHandler.
+ */
+ reset: function ()
+ {
+ this.lastCalled = new Date().getTime();
+ },
+
+ /** PrivateFunction: toString
+ * Get a string representation of the Strophe.TimedHandler object.
+ *
+ * Returns:
+ * The string representation.
+ */
+ toString: function ()
+ {
+ return "{TimedHandler: " + this.handler + "(" + this.period +")}";
+ }
+};
+
+/** PrivateClass: Strophe.Request
+ * _Private_ helper class that provides a cross implementation abstraction
+ * for a BOSH related XMLHttpRequest.
+ *
+ * The Strophe.Request class is used internally to encapsulate BOSH request
+ * information. It is not meant to be used from user's code.
+ */
+
+/** PrivateConstructor: Strophe.Request
+ * Create and initialize a new Strophe.Request object.
+ *
+ * Parameters:
+ * (XMLElement) elem - The XML data to be sent in the request.
+ * (Function) func - The function that will be called when the
+ * XMLHttpRequest readyState changes.
+ * (Integer) rid - The BOSH rid attribute associated with this request.
+ * (Integer) sends - The number of times this same request has been
+ * sent.
+ */
+Strophe.Request = function (elem, func, rid, sends)
+{
+ this.id = ++Strophe._requestId;
+ this.xmlData = elem;
+ this.data = Strophe.serialize(elem);
+ // save original function in case we need to make a new request
+ // from this one.
+ this.origFunc = func;
+ this.func = func;
+ this.rid = rid;
+ this.date = NaN;
+ this.sends = sends || 0;
+ this.abort = false;
+ this.dead = null;
+ this.age = function () {
+ if (!this.date) { return 0; }
+ var now = new Date();
+ return (now - this.date) / 1000;
+ };
+ this.timeDead = function () {
+ if (!this.dead) { return 0; }
+ var now = new Date();
+ return (now - this.dead) / 1000;
+ };
+ this.xhr = this._newXHR();
+};
+
+Strophe.Request.prototype = {
+ /** PrivateFunction: getResponse
+ * Get a response from the underlying XMLHttpRequest.
+ *
+ * This function attempts to get a response from the request and checks
+ * for errors.
+ *
+ * Throws:
+ * "parsererror" - A parser error occured.
+ *
+ * Returns:
+ * The DOM element tree of the response.
+ */
+ getResponse: function ()
+ {
+ var node = null;
+ if (this.xhr.responseXML && this.xhr.responseXML.documentElement) {
+ node = this.xhr.responseXML.documentElement;
+ if (node.tagName == "parsererror") {
+ Strophe.error("invalid response received");
+ Strophe.error("responseText: " + this.xhr.responseText);
+ Strophe.error("responseXML: " +
+ Strophe.serialize(this.xhr.responseXML));
+ throw "parsererror";
+ }
+ } else if (this.xhr.responseText) {
+ Strophe.error("invalid response received");
+ Strophe.error("responseText: " + this.xhr.responseText);
+ Strophe.error("responseXML: " +
+ Strophe.serialize(this.xhr.responseXML));
+ }
+
+ return node;
+ },
+
+ /** PrivateFunction: _newXHR
+ * _Private_ helper function to create XMLHttpRequests.
+ *
+ * This function creates XMLHttpRequests across all implementations.
+ *
+ * Returns:
+ * A new XMLHttpRequest.
+ */
+ _newXHR: function ()
+ {
+ var xhr = null;
+ if (window.XMLHttpRequest) {
+ xhr = new XMLHttpRequest();
+ if (xhr.overrideMimeType) {
+ xhr.overrideMimeType("text/xml");
+ }
+ } else if (window.ActiveXObject) {
+ xhr = new ActiveXObject("Microsoft.XMLHTTP");
+ }
+
+ xhr.onreadystatechange = this.func.prependArg(this);
+
+ return xhr;
+ }
+};
+
+/** Class: Strophe.Connection
+ * XMPP Connection manager.
+ *
+ * Thie class is the main part of Strophe. It manages a BOSH connection
+ * to an XMPP server and dispatches events to the user callbacks as
+ * data arrives. It supports SASL PLAIN, SASL DIGEST-MD5, and legacy
+ * authentication.
+ *
+ * After creating a Strophe.Connection object, the user will typically
+ * call connect() with a user supplied callback to handle connection level
+ * events like authentication failure, disconnection, or connection
+ * complete.
+ *
+ * The user will also have several event handlers defined by using
+ * addHandler() and addTimedHandler(). These will allow the user code to
+ * respond to interesting stanzas or do something periodically with the
+ * connection. These handlers will be active once authentication is
+ * finished.
+ *
+ * To send data to the connection, use send().
+ */
+
+/** Constructor: Strophe.Connection
+ * Create and initialize a Strophe.Connection object.
+ *
+ * Parameters:
+ * (String) service - The BOSH service URL.
+ *
+ * Returns:
+ * A new Strophe.Connection object.
+ */
+Strophe.Connection = function (service)
+{
+ /* The path to the httpbind service. */
+ this.service = service;
+ /* The connected JID. */
+ this.jid = "";
+ /* request id for body tags */
+ this.rid = Math.floor(Math.random() * 4294967295);
+ /* The current session ID. */
+ this.sid = null;
+ this.streamId = null;
+
+ // SASL
+ this.do_session = false;
+ this.do_bind = false;
+
+ // handler lists
+ this.timedHandlers = [];
+ this.handlers = [];
+ this.removeTimeds = [];
+ this.removeHandlers = [];
+ this.addTimeds = [];
+ this.addHandlers = [];
+
+ this._idleTimeout = null;
+ this._disconnectTimeout = null;
+
+ this.authenticated = false;
+ this.disconnecting = false;
+ this.connected = false;
+
+ this.errors = 0;
+
+ this.paused = false;
+
+ // default BOSH values
+ this.hold = 1;
+ this.wait = 60;
+ this.window = 5;
+
+ this._data = [];
+ this._requests = [];
+ this._uniqueId = Math.round(Math.random() * 10000);
+
+ this._sasl_success_handler = null;
+ this._sasl_failure_handler = null;
+ this._sasl_challenge_handler = null;
+
+ // setup onIdle callback every 1/10th of a second
+ this._idleTimeout = setTimeout(this._onIdle.bind(this), 100);
+
+ // initialize plugins
+ for (var k in Strophe._connectionPlugins) {
+ if (Strophe._connectionPlugins.hasOwnProperty(k)) {
+ var ptype = Strophe._connectionPlugins[k];
+ // jslint complaints about the below line, but this is fine
+ var F = function () {};
+ F.prototype = ptype;
+ this[k] = new F();
+ this[k].init(this);
+ }
+ }
+};
+
+Strophe.Connection.prototype = {
+ /** Function: reset
+ * Reset the connection.
+ *
+ * This function should be called after a connection is disconnected
+ * before that connection is reused.
+ */
+ reset: function ()
+ {
+ this.rid = Math.floor(Math.random() * 4294967295);
+
+ this.sid = null;
+ this.streamId = null;
+
+ // SASL
+ this.do_session = false;
+ this.do_bind = false;
+
+ // handler lists
+ this.timedHandlers = [];
+ this.handlers = [];
+ this.removeTimeds = [];
+ this.removeHandlers = [];
+ this.addTimeds = [];
+ this.addHandlers = [];
+
+ this.authenticated = false;
+ this.disconnecting = false;
+ this.connected = false;
+
+ this.errors = 0;
+
+ this._requests = [];
+ this._uniqueId = Math.round(Math.random()*10000);
+ },
+
+ /** Function: pause
+ * Pause the request manager.
+ *
+ * This will prevent Strophe from sending any more requests to the
+ * server. This is very useful for temporarily pausing while a lot
+ * of send() calls are happening quickly. This causes Strophe to
+ * send the data in a single request, saving many request trips.
+ */
+ pause: function ()
+ {
+ this.paused = true;
+ },
+
+ /** Function: resume
+ * Resume the request manager.
+ *
+ * This resumes after pause() has been called.
+ */
+ resume: function ()
+ {
+ this.paused = false;
+ },
+
+ /** Function: getUniqueId
+ * Generate a unique ID for use in <iq/> elements.
+ *
+ * All <iq/> stanzas are required to have unique id attributes. This
+ * function makes creating these easy. Each connection instance has
+ * a counter which starts from zero, and the value of this counter
+ * plus a colon followed by the suffix becomes the unique id. If no
+ * suffix is supplied, the counter is used as the unique id.
+ *
+ * Suffixes are used to make debugging easier when reading the stream
+ * data, and their use is recommended. The counter resets to 0 for
+ * every new connection for the same reason. For connections to the
+ * same server that authenticate the same way, all the ids should be
+ * the same, which makes it easy to see changes. This is useful for
+ * automated testing as well.
+ *
+ * Parameters:
+ * (String) suffix - A optional suffix to append to the id.
+ *
+ * Returns:
+ * A unique string to be used for the id attribute.
+ */
+ getUniqueId: function (suffix)
+ {
+ if (typeof(suffix) == "string" || typeof(suffix) == "number") {
+ return ++this._uniqueId + ":" + suffix;
+ } else {
+ return ++this._uniqueId + "";
+ }
+ },
+
+ /** Function: connect
+ * Starts the connection process.
+ *
+ * As the connection process proceeds, the user supplied callback will
+ * be triggered multiple times with status updates. The callback
+ * should take two arguments - the status code and the error condition.
+ *
+ * The status code will be one of the values in the Strophe.Status
+ * constants. The error condition will be one of the conditions
+ * defined in RFC 3920 or the condition 'strophe-parsererror'.
+ *
+ * Please see XEP 124 for a more detailed explanation of the optional
+ * parameters below.
+ *
+ * Parameters:
+ * (String) jid - The user's JID. This may be a bare JID,
+ * or a full JID. If a node is not supplied, SASL ANONYMOUS
+ * authentication will be attempted.
+ * (String) pass - The user's password.
+ * (Function) callback The connect callback function.
+ * (Integer) wait - The optional HTTPBIND wait value. This is the
+ * time the server will wait before returning an empty result for
+ * a request. The default setting of 60 seconds is recommended.
+ * Other settings will require tweaks to the Strophe.TIMEOUT value.
+ * (Integer) hold - The optional HTTPBIND hold value. This is the
+ * number of connections the server will hold at one time. This
+ * should almost always be set to 1 (the default).
+ */
+ connect: function (jid, pass, callback, wait, hold)
+ {
+ this.jid = jid;
+ this.pass = pass;
+ this.connect_callback = callback;
+ this.disconnecting = false;
+ this.connected = false;
+ this.authenticated = false;
+ this.errors = 0;
+
+ this.wait = wait || this.wait;
+ this.hold = hold || this.hold;
+
+ // parse jid for domain and resource
+ this.domain = Strophe.getDomainFromJid(this.jid);
+
+ // build the body tag
+ var body = this._buildBody().attrs({
+ to: this.domain,
+ "xml:lang": "en",
+ wait: this.wait,
+ hold: this.hold,
+ content: "text/xml; charset=utf-8",
+ ver: "1.6",
+ "xmpp:version": "1.0",
+ "xmlns:xmpp": Strophe.NS.BOSH
+ });
+
+ this._changeConnectStatus(Strophe.Status.CONNECTING, null);
+
+ this._requests.push(
+ new Strophe.Request(body.tree(),
+ this._onRequestStateChange.bind(this)
+ .prependArg(this._connect_cb.bind(this)),
+ body.tree().getAttribute("rid")));
+ this._throttledRequestHandler();
+ },
+
+ /** Function: attach
+ * Attach to an already created and authenticated BOSH session.
+ *
+ * This function is provided to allow Strophe to attach to BOSH
+ * sessions which have been created externally, perhaps by a Web
+ * application. This is often used to support auto-login type features
+ * without putting user credentials into the page.
+ *
+ * Parameters:
+ * (String) jid - The full JID that is bound by the session.
+ * (String) sid - The SID of the BOSH session.
+ * (String) rid - The current RID of the BOSH session. This RID
+ * will be used by the next request.
+ * (Function) callback The connect callback function.
+ * (Integer) wait - The optional HTTPBIND wait value. This is the
+ * time the server will wait before returning an empty result for
+ * a request. The default setting of 60 seconds is recommended.
+ * Other settings will require tweaks to the Strophe.TIMEOUT value.
+ * (Integer) hold - The optional HTTPBIND hold value. This is the
+ * number of connections the server will hold at one time. This
+ * should almost always be set to 1 (the default).
+ * (Integer) wind - The optional HTTBIND window value. This is the
+ * allowed range of request ids that are valid. The default is 5.
+ */
+ attach: function (jid, sid, rid, callback, wait, hold, wind)
+ {
+ this.jid = jid;
+ this.sid = sid;
+ this.rid = rid;
+ this.connect_callback = callback;
+
+ this.domain = Strophe.getDomainFromJid(this.jid);
+
+ this.authenticated = true;
+ this.connected = true;
+
+ this.wait = wait || this.wait;
+ this.hold = hold || this.hold;
+ this.window = wind || this.window;
+
+ this._changeConnectStatus(Strophe.Status.ATTACHED, null);
+ },
+
+ /** Function: xmlInput
+ * User overrideable function that receives XML data coming into the
+ * connection.
+ *
+ * The default function does nothing. User code can override this with
+ * > Strophe.Connection.xmlInput = function (elem) {
+ * > (user code)
+ * > };
+ *
+ * Parameters:
+ * (XMLElement) elem - The XML data received by the connection.
+ */
+ xmlInput: function (elem)
+ {
+ return;
+ },
+
+ /** Function: xmlOutput
+ * User overrideable function that receives XML data sent to the
+ * connection.
+ *
+ * The default function does nothing. User code can override this with
+ * > Strophe.Connection.xmlOutput = function (elem) {
+ * > (user code)
+ * > };
+ *
+ * Parameters:
+ * (XMLElement) elem - The XMLdata sent by the connection.
+ */
+ xmlOutput: function (elem)
+ {
+ return;
+ },
+
+ /** Function: rawInput
+ * User overrideable function that receives raw data coming into the
+ * connection.
+ *
+ * The default function does nothing. User code can override this with
+ * > Strophe.Connection.rawInput = function (data) {
+ * > (user code)
+ * > };
+ *
+ * Parameters:
+ * (String) data - The data received by the connection.
+ */
+ rawInput: function (data)
+ {
+ return;
+ },
+
+ /** Function: rawOutput
+ * User overrideable function that receives raw data sent to the
+ * connection.
+ *
+ * The default function does nothing. User code can override this with
+ * > Strophe.Connection.rawOutput = function (data) {
+ * > (user code)
+ * > };
+ *
+ * Parameters:
+ * (String) data - The data sent by the connection.
+ */
+ rawOutput: function (data)
+ {
+ return;
+ },
+
+ /** Function: send
+ * Send a stanza.
+ *
+ * This function is called to push data onto the send queue to
+ * go out over the wire. Whenever a request is sent to the BOSH
+ * server, all pending data is sent and the queue is flushed.
+ *
+ * Parameters:
+ * (XMLElement |
+ * [XMLElement] |
+ * Strophe.Builder) elem - The stanza to send.
+ */
+ send: function (elem)
+ {
+ if (elem === null) { return ; }
+ if (typeof(elem.sort) === "function") {
+ for (var i = 0; i < elem.length; i++) {
+ this._queueData(elem[i]);
+ }
+ } else if (typeof(elem.tree) === "function") {
+ this._queueData(elem.tree());
+ } else {
+ this._queueData(elem);
+ }
+
+ this._throttledRequestHandler();
+ clearTimeout(this._idleTimeout);
+ this._idleTimeout = setTimeout(this._onIdle.bind(this), 100);
+ },
+
+ /** Function: flush
+ * Immediately send any pending outgoing data.
+ *
+ * Normally send() queues outgoing data until the next idle period
+ * (100ms), which optimizes network use in the common cases when
+ * several send()s are called in succession. flush() can be used to
+ * immediately send all pending data.
+ */
+ flush: function ()
+ {
+ // cancel the pending idle period and run the idle function
+ // immediately
+ clearTimeout(this._idleTimeout);
+ this._onIdle();
+ },
+
+ /** Function: sendIQ
+ * Helper function to send IQ stanzas.
+ *
+ * Parameters:
+ * (XMLElement) elem - The stanza to send.
+ * (Function) callback - The callback function for a successful request.
+ * (Function) errback - The callback function for a failed or timed
+ * out request. On timeout, the stanza will be null.
+ * (Integer) timeout - The time specified in milliseconds for a
+ * timeout to occur.
+ *
+ * Returns:
+ * The id used to send the IQ.
+ */
+ sendIQ: function(elem, callback, errback, timeout) {
+ var timeoutHandler = null;
+ var that = this;
+
+ if (typeof(elem.tree) === "function") {
+ elem = elem.tree();
+ }
+ var id = elem.getAttribute('id');
+
+ // inject id if not found
+ if (!id) {
+ id = this.getUniqueId("sendIQ");
+ elem.setAttribute("id", id);
+ }
+
+ var handler = this.addHandler(function (stanza) {
+ // remove timeout handler if there is one
+ if (timeoutHandler) {
+ that.deleteTimedHandler(timeoutHandler);
+ }
+
+ var iqtype = stanza.getAttribute('type');
+ if (iqtype == 'result') {
+ if (callback) {
+ callback(stanza);
+ }
+ } else if (iqtype == 'error') {
+ if (errback) {
+ errback(stanza);
+ }
+ } else {
+ throw {
+ name: "StropheError",
+ message: "Got bad IQ type of " + iqtype
+ };
+ }
+ }, null, 'iq', null, id);
+
+ // if timeout specified, setup timeout handler.
+ if (timeout) {
+ timeoutHandler = this.addTimedHandler(timeout, function () {
+ // get rid of normal handler
+ that.deleteHandler(handler);
+
+ // call errback on timeout with null stanza
+ if (errback) {
+ errback(null);
+ }
+ return false;
+ });
+ }
+
+ this.send(elem);
+
+ return id;
+ },
+
+ /** PrivateFunction: _queueData
+ * Queue outgoing data for later sending. Also ensures that the data
+ * is a DOMElement.
+ */
+ _queueData: function (element) {
+ if (element === null ||
+ !element.tagName ||
+ !element.childNodes) {
+ throw {
+ name: "StropheError",
+ message: "Cannot queue non-DOMElement."
+ };
+ }
+
+ this._data.push(element);
+ },
+
+ /** PrivateFunction: _sendRestart
+ * Send an xmpp:restart stanza.
+ */
+ _sendRestart: function ()
+ {
+ this._data.push("restart");
+
+ this._throttledRequestHandler();
+ clearTimeout(this._idleTimeout);
+ this._idleTimeout = setTimeout(this._onIdle.bind(this), 100);
+ },
+
+ /** Function: addTimedHandler
+ * Add a timed handler to the connection.
+ *
+ * This function adds a timed handler. The provided handler will
+ * be called every period milliseconds until it returns false,
+ * the connection is terminated, or the handler is removed. Handlers
+ * that wish to continue being invoked should return true.
+ *
+ * Because of method binding it is necessary to save the result of
+ * this function if you wish to remove a handler with
+ * deleteTimedHandler().
+ *
+ * Note that user handlers are not active until authentication is
+ * successful.
+ *
+ * Parameters:
+ * (Integer) period - The period of the handler.
+ * (Function) handler - The callback function.
+ *
+ * Returns:
+ * A reference to the handler that can be used to remove it.
+ */
+ addTimedHandler: function (period, handler)
+ {
+ var thand = new Strophe.TimedHandler(period, handler);
+ this.addTimeds.push(thand);
+ return thand;
+ },
+
+ /** Function: deleteTimedHandler
+ * Delete a timed handler for a connection.
+ *
+ * This function removes a timed handler from the connection. The
+ * handRef parameter is *not* the function passed to addTimedHandler(),
+ * but is the reference returned from addTimedHandler().
+ *
+ * Parameters:
+ * (Strophe.TimedHandler) handRef - The handler reference.
+ */
+ deleteTimedHandler: function (handRef)
+ {
+ // this must be done in the Idle loop so that we don't change
+ // the handlers during iteration
+ this.removeTimeds.push(handRef);
+ },
+
+ /** Function: addHandler
+ * Add a stanza handler for the connection.
+ *
+ * This function adds a stanza handler to the connection. The
+ * handler callback will be called for any stanza that matches
+ * the parameters. Note that if multiple parameters are supplied,
+ * they must all match for the handler to be invoked.
+ *
+ * The handler will receive the stanza that triggered it as its argument.
+ * The handler should return true if it is to be invoked again;
+ * returning false will remove the handler after it returns.
+ *
+ * As a convenience, the ns parameters applies to the top level element
+ * and also any of its immediate children. This is primarily to make
+ * matching /iq/query elements easy.
+ *
+ * The options argument contains handler matching flags that affect how
+ * matches are determined. Currently the only flag is matchBare (a
+ * boolean). When matchBare is true, the from parameter and the from
+ * attribute on the stanza will be matched as bare JIDs instead of
+ * full JIDs. To use this, pass {matchBare: true} as the value of
+ * options. The default value for matchBare is false.
+ *
+ * The return value should be saved if you wish to remove the handler
+ * with deleteHandler().
+ *
+ * Parameters:
+ * (Function) handler - The user callback.
+ * (String) ns - The namespace to match.
+ * (String) name - The stanza name to match.
+ * (String) type - The stanza type attribute to match.
+ * (String) id - The stanza id attribute to match.
+ * (String) from - The stanza from attribute to match.
+ * (String) options - The handler options
+ *
+ * Returns:
+ * A reference to the handler that can be used to remove it.
+ */
+ addHandler: function (handler, ns, name, type, id, from, options)
+ {
+ var hand = new Strophe.Handler(handler, ns, name, type, id, from, options);
+ this.addHandlers.push(hand);
+ return hand;
+ },
+
+ /** Function: deleteHandler
+ * Delete a stanza handler for a connection.
+ *
+ * This function removes a stanza handler from the connection. The
+ * handRef parameter is *not* the function passed to addHandler(),
+ * but is the reference returned from addHandler().
+ *
+ * Parameters:
+ * (Strophe.Handler) handRef - The handler reference.
+ */
+ deleteHandler: function (handRef)
+ {
+ // this must be done in the Idle loop so that we don't change
+ // the handlers during iteration
+ this.removeHandlers.push(handRef);
+ },
+
+ /** Function: disconnect
+ * Start the graceful disconnection process.
+ *
+ * This function starts the disconnection process. This process starts
+ * by sending unavailable presence and sending BOSH body of type
+ * terminate. A timeout handler makes sure that disconnection happens
+ * even if the BOSH server does not respond.
+ *
+ * The user supplied connection callback will be notified of the
+ * progress as this process happens.
+ *
+ * Parameters:
+ * (String) reason - The reason the disconnect is occuring.
+ */
+ disconnect: function (reason)
+ {
+ this._changeConnectStatus(Strophe.Status.DISCONNECTING, reason);
+
+ Strophe.info("Disconnect was called because: " + reason);
+ if (this.connected) {
+ // setup timeout handler
+ this._disconnectTimeout = this._addSysTimedHandler(
+ 3000, this._onDisconnectTimeout.bind(this));
+ this._sendTerminate();
+ }
+ },
+
+ /** PrivateFunction: _changeConnectStatus
+ * _Private_ helper function that makes sure plugins and the user's
+ * callback are notified of connection status changes.
+ *
+ * Parameters:
+ * (Integer) status - the new connection status, one of the values
+ * in Strophe.Status
+ * (String) condition - the error condition or null
+ */
+ _changeConnectStatus: function (status, condition)
+ {
+ // notify all plugins listening for status changes
+ for (var k in Strophe._connectionPlugins) {
+ if (Strophe._connectionPlugins.hasOwnProperty(k)) {
+ var plugin = this[k];
+ if (plugin.statusChanged) {
+ try {
+ plugin.statusChanged(status, condition);
+ } catch (err) {
+ Strophe.error("" + k + " plugin caused an exception " +
+ "changing status: " + err);
+ }
+ }
+ }
+ }
+
+ // notify the user's callback
+ if (this.connect_callback) {
+ try {
+ this.connect_callback(status, condition);
+ } catch (e) {
+ Strophe.error("User connection callback caused an " +
+ "exception: " + e);
+ }
+ }
+ },
+
+ /** PrivateFunction: _buildBody
+ * _Private_ helper function to generate the <body/> wrapper for BOSH.
+ *
+ * Returns:
+ * A Strophe.Builder with a <body/> element.
+ */
+ _buildBody: function ()
+ {
+ var bodyWrap = $build('body', {
+ rid: this.rid++,
+ xmlns: Strophe.NS.HTTPBIND
+ });
+
+ if (this.sid !== null) {
+ bodyWrap.attrs({sid: this.sid});
+ }
+
+ return bodyWrap;
+ },
+
+ /** PrivateFunction: _removeRequest
+ * _Private_ function to remove a request from the queue.
+ *
+ * Parameters:
+ * (Strophe.Request) req - The request to remove.
+ */
+ _removeRequest: function (req)
+ {
+ Strophe.debug("removing request");
+
+ var i;
+ for (i = this._requests.length - 1; i >= 0; i--) {
+ if (req == this._requests[i]) {
+ this._requests.splice(i, 1);
+ }
+ }
+
+ // IE6 fails on setting to null, so set to empty function
+ req.xhr.onreadystatechange = function () {};
+
+ this._throttledRequestHandler();
+ },
+
+ /** PrivateFunction: _restartRequest
+ * _Private_ function to restart a request that is presumed dead.
+ *
+ * Parameters:
+ * (Integer) i - The index of the request in the queue.
+ */
+ _restartRequest: function (i)
+ {
+ var req = this._requests[i];
+ if (req.dead === null) {
+ req.dead = new Date();
+ }
+
+ this._processRequest(i);
+ },
+
+ /** PrivateFunction: _processRequest
+ * _Private_ function to process a request in the queue.
+ *
+ * This function takes requests off the queue and sends them and
+ * restarts dead requests.
+ *
+ * Parameters:
+ * (Integer) i - The index of the request in the queue.
+ */
+ _processRequest: function (i)
+ {
+ var req = this._requests[i];
+ var reqStatus = -1;
+
+ try {
+ if (req.xhr.readyState == 4) {
+ reqStatus = req.xhr.status;
+ }
+ } catch (e) {
+ Strophe.error("caught an error in _requests[" + i +
+ "], reqStatus: " + reqStatus);
+ }
+
+ if (typeof(reqStatus) == "undefined") {
+ reqStatus = -1;
+ }
+
+ var time_elapsed = req.age();
+ var primaryTimeout = (!isNaN(time_elapsed) &&
+ time_elapsed > Math.floor(Strophe.TIMEOUT * this.wait));
+ var secondaryTimeout = (req.dead !== null &&
+ req.timeDead() > Math.floor(Strophe.SECONDARY_TIMEOUT * this.wait));
+ var requestCompletedWithServerError = (req.xhr.readyState == 4 &&
+ (reqStatus < 1 ||
+ reqStatus >= 500));
+ if (primaryTimeout || secondaryTimeout ||
+ requestCompletedWithServerError) {
+ if (secondaryTimeout) {
+ Strophe.error("Request " +
+ this._requests[i].id +
+ " timed out (secondary), restarting");
+ }
+ req.abort = true;
+ req.xhr.abort();
+ // setting to null fails on IE6, so set to empty function
+ req.xhr.onreadystatechange = function () {};
+ this._requests[i] = new Strophe.Request(req.xmlData,
+ req.origFunc,
+ req.rid,
+ req.sends);
+ req = this._requests[i];
+ }
+
+ if (req.xhr.readyState === 0) {
+ Strophe.debug("request id " + req.id +
+ "." + req.sends + " posting");
+
+ req.date = new Date();
+ try {
+ req.xhr.open("POST", this.service, true);
+ } catch (e2) {
+ Strophe.error("XHR open failed.");
+ if (!this.connected) {
+ this._changeConnectStatus(Strophe.Status.CONNFAIL,
+ "bad-service");
+ }
+ this.disconnect();
+ return;
+ }
+
+ // Fires the XHR request -- may be invoked immediately
+ // or on a gradually expanding retry window for reconnects
+ var sendFunc = function () {
+ req.xhr.send(req.data);
+ };
+
+ // Implement progressive backoff for reconnects --
+ // First retry (send == 1) should also be instantaneous
+ if (req.sends > 1) {
+ // Using a cube of the retry number creats a nicely
+ // expanding retry window
+ var backoff = Math.pow(req.sends, 3) * 1000;
+ setTimeout(sendFunc, backoff);
+ } else {
+ sendFunc();
+ }
+
+ req.sends++;
+
+ this.xmlOutput(req.xmlData);
+ this.rawOutput(req.data);
+ } else {
+ Strophe.debug("_processRequest: " +
+ (i === 0 ? "first" : "second") +
+ " request has readyState of " +
+ req.xhr.readyState);
+ }
+ },
+
+ /** PrivateFunction: _throttledRequestHandler
+ * _Private_ function to throttle requests to the connection window.
+ *
+ * This function makes sure we don't send requests so fast that the
+ * request ids overflow the connection window in the case that one
+ * request died.
+ */
+ _throttledRequestHandler: function ()
+ {
+ if (!this._requests) {
+ Strophe.debug("_throttledRequestHandler called with " +
+ "undefined requests");
+ } else {
+ Strophe.debug("_throttledRequestHandler called with " +
+ this._requests.length + " requests");
+ }
+
+ if (!this._requests || this._requests.length === 0) {
+ return;
+ }
+
+ if (this._requests.length > 0) {
+ this._processRequest(0);
+ }
+
+ if (this._requests.length > 1 &&
+ Math.abs(this._requests[0].rid -
+ this._requests[1].rid) < this.window - 1) {
+ this._processRequest(1);
+ }
+ },
+
+ /** PrivateFunction: _onRequestStateChange
+ * _Private_ handler for Strophe.Request state changes.
+ *
+ * This function is called when the XMLHttpRequest readyState changes.
+ * It contains a lot of error handling logic for the many ways that
+ * requests can fail, and calls the request callback when requests
+ * succeed.
+ *
+ * Parameters:
+ * (Function) func - The handler for the request.
+ * (Strophe.Request) req - The request that is changing readyState.
+ */
+ _onRequestStateChange: function (func, req)
+ {
+ Strophe.debug("request id " + req.id +
+ "." + req.sends + " state changed to " +
+ req.xhr.readyState);
+
+ if (req.abort) {
+ req.abort = false;
+ return;
+ }
+
+ // request complete
+ var reqStatus;
+ if (req.xhr.readyState == 4) {
+ reqStatus = 0;
+ try {
+ reqStatus = req.xhr.status;
+ } catch (e) {
+ // ignore errors from undefined status attribute. works
+ // around a browser bug
+ }
+
+ if (typeof(reqStatus) == "undefined") {
+ reqStatus = 0;
+ }
+
+ if (this.disconnecting) {
+ if (reqStatus >= 400) {
+ this._hitError(reqStatus);
+ return;
+ }
+ }
+
+ var reqIs0 = (this._requests[0] == req);
+ var reqIs1 = (this._requests[1] == req);
+
+ if ((reqStatus > 0 && reqStatus < 500) || req.sends > 5) {
+ // remove from internal queue
+ this._removeRequest(req);
+ Strophe.debug("request id " +
+ req.id +
+ " should now be removed");
+ }
+
+ // request succeeded
+ if (reqStatus == 200) {
+ // if request 1 finished, or request 0 finished and request
+ // 1 is over Strophe.SECONDARY_TIMEOUT seconds old, we need to
+ // restart the other - both will be in the first spot, as the
+ // completed request has been removed from the queue already
+ if (reqIs1 ||
+ (reqIs0 && this._requests.length > 0 &&
+ this._requests[0].age() > Math.floor(Strophe.SECONDARY_TIMEOUT * this.wait))) {
+ this._restartRequest(0);
+ }
+ // call handler
+ Strophe.debug("request id " +
+ req.id + "." +
+ req.sends + " got 200");
+ func(req);
+ this.errors = 0;
+ } else {
+ Strophe.error("request id " +
+ req.id + "." +
+ req.sends + " error " + reqStatus +
+ " happened");
+ if (reqStatus === 0 ||
+ (reqStatus >= 400 && reqStatus < 600) ||
+ reqStatus >= 12000) {
+ this._hitError(reqStatus);
+ if (reqStatus >= 400 && reqStatus < 500) {
+ this._changeConnectStatus(Strophe.Status.DISCONNECTING,
+ null);
+ this._doDisconnect();
+ }
+ }
+ }
+
+ if (!((reqStatus > 0 && reqStatus < 10000) ||
+ req.sends > 5)) {
+ this._throttledRequestHandler();
+ }
+ }
+ },
+
+ /** PrivateFunction: _hitError
+ * _Private_ function to handle the error count.
+ *
+ * Requests are resent automatically until their error count reaches
+ * 5. Each time an error is encountered, this function is called to
+ * increment the count and disconnect if the count is too high.
+ *
+ * Parameters:
+ * (Integer) reqStatus - The request status.
+ */
+ _hitError: function (reqStatus)
+ {
+ this.errors++;
+ Strophe.warn("request errored, status: " + reqStatus +
+ ", number of errors: " + this.errors);
+ if (this.errors > 4) {
+ this._onDisconnectTimeout();
+ }
+ },
+
+ /** PrivateFunction: _doDisconnect
+ * _Private_ function to disconnect.
+ *
+ * This is the last piece of the disconnection logic. This resets the
+ * connection and alerts the user's connection callback.
+ */
+ _doDisconnect: function ()
+ {
+ Strophe.info("_doDisconnect was called");
+ this.authenticated = false;
+ this.disconnecting = false;
+ this.sid = null;
+ this.streamId = null;
+ this.rid = Math.floor(Math.random() * 4294967295);
+
+ // tell the parent we disconnected
+ if (this.connected) {
+ this._changeConnectStatus(Strophe.Status.DISCONNECTED, null);
+ this.connected = false;
+ }
+
+ // delete handlers
+ this.handlers = [];
+ this.timedHandlers = [];
+ this.removeTimeds = [];
+ this.removeHandlers = [];
+ this.addTimeds = [];
+ this.addHandlers = [];
+ },
+
+ /** PrivateFunction: _dataRecv
+ * _Private_ handler to processes incoming data from the the connection.
+ *
+ * Except for _connect_cb handling the initial connection request,
+ * this function handles the incoming data for all requests. This
+ * function also fires stanza handlers that match each incoming
+ * stanza.
+ *
+ * Parameters:
+ * (Strophe.Request) req - The request that has data ready.
+ */
+ _dataRecv: function (req)
+ {
+ try {
+ var elem = req.getResponse();
+ } catch (e) {
+ if (e != "parsererror") { throw e; }
+ this.disconnect("strophe-parsererror");
+ }
+ if (elem === null) { return; }
+
+ this.xmlInput(elem);
+ this.rawInput(Strophe.serialize(elem));
+
+ // remove handlers scheduled for deletion
+ var i, hand;
+ while (this.removeHandlers.length > 0) {
+ hand = this.removeHandlers.pop();
+ i = this.handlers.indexOf(hand);
+ if (i >= 0) {
+ this.handlers.splice(i, 1);
+ }
+ }
+
+ // add handlers scheduled for addition
+ while (this.addHandlers.length > 0) {
+ this.handlers.push(this.addHandlers.pop());
+ }
+
+ // handle graceful disconnect
+ if (this.disconnecting && this._requests.length === 0) {
+ this.deleteTimedHandler(this._disconnectTimeout);
+ this._disconnectTimeout = null;
+ this._doDisconnect();
+ return;
+ }
+
+ var typ = elem.getAttribute("type");
+ var cond, conflict;
+ if (typ !== null && typ == "terminate") {
+ // an error occurred
+ cond = elem.getAttribute("condition");
+ conflict = elem.getElementsByTagName("conflict");
+ if (cond !== null) {
+ if (cond == "remote-stream-error" && conflict.length > 0) {
+ cond = "conflict";
+ }
+ this._changeConnectStatus(Strophe.Status.CONNFAIL, cond);
+ } else {
+ this._changeConnectStatus(Strophe.Status.CONNFAIL, "unknown");
+ }
+ this.disconnect();
+ return;
+ }
+
+ // send each incoming stanza through the handler chain
+ var that = this;
+ Strophe.forEachChild(elem, null, function (child) {
+ var i, newList;
+ // process handlers
+ newList = that.handlers;
+ that.handlers = [];
+ for (i = 0; i < newList.length; i++) {
+ var hand = newList[i];
+ if (hand.isMatch(child) &&
+ (that.authenticated || !hand.user)) {
+ if (hand.run(child)) {
+ that.handlers.push(hand);
+ }
+ } else {
+ that.handlers.push(hand);
+ }
+ }
+ });
+ },
+
+ /** PrivateFunction: _sendTerminate
+ * _Private_ function to send initial disconnect sequence.
+ *
+ * This is the first step in a graceful disconnect. It sends
+ * the BOSH server a terminate body and includes an unavailable
+ * presence if authentication has completed.
+ */
+ _sendTerminate: function ()
+ {
+ Strophe.info("_sendTerminate was called");
+ var body = this._buildBody().attrs({type: "terminate"});
+
+ if (this.authenticated) {
+ body.c('presence', {
+ xmlns: Strophe.NS.CLIENT,
+ type: 'unavailable'
+ });
+ }
+
+ this.disconnecting = true;
+
+ var req = new Strophe.Request(body.tree(),
+ this._onRequestStateChange.bind(this)
+ .prependArg(this._dataRecv.bind(this)),
+ body.tree().getAttribute("rid"));
+
+ this._requests.push(req);
+ this._throttledRequestHandler();
+ },
+
+ /** PrivateFunction: _connect_cb
+ * _Private_ handler for initial connection request.
+ *
+ * This handler is used to process the initial connection request
+ * response from the BOSH server. It is used to set up authentication
+ * handlers and start the authentication process.
+ *
+ * SASL authentication will be attempted if available, otherwise
+ * the code will fall back to legacy authentication.
+ *
+ * Parameters:
+ * (Strophe.Request) req - The current request.
+ */
+ _connect_cb: function (req)
+ {
+ Strophe.info("_connect_cb was called");
+
+ this.connected = true;
+ var bodyWrap = req.getResponse();
+ if (!bodyWrap) { return; }
+
+ this.xmlInput(bodyWrap);
+ this.rawInput(Strophe.serialize(bodyWrap));
+
+ var typ = bodyWrap.getAttribute("type");
+ var cond, conflict;
+ if (typ !== null && typ == "terminate") {
+ // an error occurred
+ cond = bodyWrap.getAttribute("condition");
+ conflict = bodyWrap.getElementsByTagName("conflict");
+ if (cond !== null) {
+ if (cond == "remote-stream-error" && conflict.length > 0) {
+ cond = "conflict";
+ }
+ this._changeConnectStatus(Strophe.Status.CONNFAIL, cond);
+ } else {
+ this._changeConnectStatus(Strophe.Status.CONNFAIL, "unknown");
+ }
+ return;
+ }
+
+ // check to make sure we don't overwrite these if _connect_cb is
+ // called multiple times in the case of missing stream:features
+ if (!this.sid) {
+ this.sid = bodyWrap.getAttribute("sid");
+ }
+ if (!this.stream_id) {
+ this.stream_id = bodyWrap.getAttribute("authid");
+ }
+ var wind = bodyWrap.getAttribute('requests');
+ if (wind) { this.window = parseInt(wind, 10); }
+ var hold = bodyWrap.getAttribute('hold');
+ if (hold) { this.hold = parseInt(hold, 10); }
+ var wait = bodyWrap.getAttribute('wait');
+ if (wait) { this.wait = parseInt(wait, 10); }
+
+
+ var do_sasl_plain = false;
+ var do_sasl_digest_md5 = false;
+ var do_sasl_anonymous = false;
+
+ var mechanisms = bodyWrap.getElementsByTagName("mechanism");
+ var i, mech, auth_str, hashed_auth_str;
+ if (mechanisms.length > 0) {
+ for (i = 0; i < mechanisms.length; i++) {
+ mech = Strophe.getText(mechanisms[i]);
+ if (mech == 'DIGEST-MD5') {
+ do_sasl_digest_md5 = true;
+ } else if (mech == 'PLAIN') {
+ do_sasl_plain = true;
+ } else if (mech == 'ANONYMOUS') {
+ do_sasl_anonymous = true;
+ }
+ }
+ } else {
+ // we didn't get stream:features yet, so we need wait for it
+ // by sending a blank poll request
+ var body = this._buildBody();
+ this._requests.push(
+ new Strophe.Request(body.tree(),
+ this._onRequestStateChange.bind(this)
+ .prependArg(this._connect_cb.bind(this)),
+ body.tree().getAttribute("rid")));
+ this._throttledRequestHandler();
+ return;
+ }
+
+ if (Strophe.getNodeFromJid(this.jid) === null &&
+ do_sasl_anonymous) {
+ this._changeConnectStatus(Strophe.Status.AUTHENTICATING, null);
+ this._sasl_success_handler = this._addSysHandler(
+ this._sasl_success_cb.bind(this), null,
+ "success", null, null);
+ this._sasl_failure_handler = this._addSysHandler(
+ this._sasl_failure_cb.bind(this), null,
+ "failure", null, null);
+
+ this.send($build("auth", {
+ xmlns: Strophe.NS.SASL,
+ mechanism: "ANONYMOUS"
+ }).tree());
+ } else if (Strophe.getNodeFromJid(this.jid) === null) {
+ // we don't have a node, which is required for non-anonymous
+ // client connections
+ this._changeConnectStatus(Strophe.Status.CONNFAIL,
+ 'x-strophe-bad-non-anon-jid');
+ this.disconnect();
+ } else if (do_sasl_digest_md5) {
+ this._changeConnectStatus(Strophe.Status.AUTHENTICATING, null);
+ this._sasl_challenge_handler = this._addSysHandler(
+ this._sasl_challenge1_cb.bind(this), null,
+ "challenge", null, null);
+ this._sasl_failure_handler = this._addSysHandler(
+ this._sasl_failure_cb.bind(this), null,
+ "failure", null, null);
+
+ this.send($build("auth", {
+ xmlns: Strophe.NS.SASL,
+ mechanism: "DIGEST-MD5"
+ }).tree());
+ } else if (do_sasl_plain) {
+ // Build the plain auth string (barejid null
+ // username null password) and base 64 encoded.
+ auth_str = Strophe.getBareJidFromJid(this.jid);
+ auth_str = auth_str + "\u0000";
+ auth_str = auth_str + Strophe.getNodeFromJid(this.jid);
+ auth_str = auth_str + "\u0000";
+ auth_str = auth_str + this.pass;
+
+ this._changeConnectStatus(Strophe.Status.AUTHENTICATING, null);
+ this._sasl_success_handler = this._addSysHandler(
+ this._sasl_success_cb.bind(this), null,
+ "success", null, null);
+ this._sasl_failure_handler = this._addSysHandler(
+ this._sasl_failure_cb.bind(this), null,
+ "failure", null, null);
+
+ hashed_auth_str = Base64.encode(auth_str);
+ this.send($build("auth", {
+ xmlns: Strophe.NS.SASL,
+ mechanism: "PLAIN"
+ }).t(hashed_auth_str).tree());
+ } else {
+ this._changeConnectStatus(Strophe.Status.AUTHENTICATING, null);
+ this._addSysHandler(this._auth1_cb.bind(this), null, null,
+ null, "_auth_1");
+
+ this.send($iq({
+ type: "get",
+ to: this.domain,
+ id: "_auth_1"
+ }).c("query", {
+ xmlns: Strophe.NS.AUTH
+ }).c("username", {}).t(Strophe.getNodeFromJid(this.jid)).tree());
+ }
+ },
+
+ /** PrivateFunction: _sasl_challenge1_cb
+ * _Private_ handler for DIGEST-MD5 SASL authentication.
+ *
+ * Parameters:
+ * (XMLElement) elem - The challenge stanza.
+ *
+ * Returns:
+ * false to remove the handler.
+ */
+ _sasl_challenge1_cb: function (elem)
+ {
+ var attribMatch = /([a-z]+)=("[^"]+"|[^,"]+)(?:,|$)/;
+
+ var challenge = Base64.decode(Strophe.getText(elem));
+ var cnonce = MD5.hexdigest(Math.random() * 1234567890);
[... 536 lines stripped ...]