4289 lines
120 KiB
JavaScript
4289 lines
120 KiB
JavaScript
/*
|
|
|
|
Jappix - An open social platform
|
|
This is the JSJaC library for Jappix (from trunk)
|
|
|
|
-------------------------------------------------
|
|
|
|
Licenses: Mozilla Public License version 1.1, GNU GPL, AGPL
|
|
Authors: Stefan Strigler, Vanaryon, Zash
|
|
Last revision: 25/08/11
|
|
|
|
*/
|
|
|
|
/**
|
|
* @fileoverview Magic dependency loading. Taken from script.aculo.us
|
|
* and modified to break it.
|
|
* @author Stefan Strigler steve@zeank.in-berlin.de
|
|
* @version $Revision$
|
|
*/
|
|
|
|
var JSJaC = {
|
|
Version: '$Rev$',
|
|
bind: function(fn, obj, optArg) {
|
|
return function(arg) {
|
|
return fn.apply(obj, [arg, optArg]);
|
|
};
|
|
}
|
|
};
|
|
|
|
if (typeof JSJaCConnection == 'undefined')
|
|
JSJaC.load();
|
|
|
|
|
|
|
|
/* Copyright 2006 Erik Arvidsson
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License"); you
|
|
* may not use this file except in compliance with the License. You
|
|
* may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
|
* implied. See the License for the specific language governing
|
|
* permissions and limitations under the License.
|
|
*/
|
|
|
|
/**
|
|
* @fileoverview Wrapper to make working with XmlHttpRequest and the
|
|
* DOM more convenient (cross browser compliance).
|
|
* this code is taken from
|
|
* http://webfx.eae.net/dhtml/xmlextras/xmlextras.html
|
|
* @author Stefan Strigler steve@zeank.in-berlin.de
|
|
* @version $Revision$
|
|
*/
|
|
|
|
/**
|
|
* XmlHttp factory
|
|
* @private
|
|
*/
|
|
function XmlHttp() {}
|
|
|
|
/**
|
|
* creates a cross browser compliant XmlHttpRequest object
|
|
*/
|
|
XmlHttp.create = function () {
|
|
try {
|
|
// Are we cross-domain?
|
|
if(((BOSH_PROXY == 'on') || (HOST_BOSH_MINI)) && (typeof jXHR == "function")) {
|
|
// Able to use CORS?
|
|
if (window.XMLHttpRequest) {
|
|
var req = new XMLHttpRequest();
|
|
|
|
if (req.withCredentials !== undefined)
|
|
return req;
|
|
}
|
|
|
|
return new jXHR();
|
|
}
|
|
// Might be local-domain?
|
|
if (window.XMLHttpRequest) {
|
|
var req = new XMLHttpRequest();
|
|
|
|
// some versions of Moz do not support the readyState property
|
|
// and the onreadystate event so we patch it!
|
|
if (req.readyState == null) {
|
|
req.readyState = 1;
|
|
req.addEventListener("load", function () {
|
|
req.readyState = 4;
|
|
if (typeof req.onreadystatechange == "function")
|
|
req.onreadystatechange();
|
|
}, false);
|
|
}
|
|
|
|
return req;
|
|
}
|
|
if (window.ActiveXObject) {
|
|
return new ActiveXObject(XmlHttp.getPrefix() + ".XmlHttp");
|
|
}
|
|
}
|
|
catch (ex) {}
|
|
// fell through
|
|
throw new Error("Your browser does not support XmlHttp objects");
|
|
};
|
|
|
|
/**
|
|
* used to find the Automation server name
|
|
* @private
|
|
*/
|
|
XmlHttp.getPrefix = function() {
|
|
if (XmlHttp.prefix) // I know what you did last summer
|
|
return XmlHttp.prefix;
|
|
|
|
var prefixes = ["MSXML2", "Microsoft", "MSXML", "MSXML3"];
|
|
var o;
|
|
for (var i = 0; i < prefixes.length; i++) {
|
|
try {
|
|
// try to create the objects
|
|
o = new ActiveXObject(prefixes[i] + ".XmlHttp");
|
|
return XmlHttp.prefix = prefixes[i];
|
|
}
|
|
catch (ex) {};
|
|
}
|
|
|
|
throw new Error("Could not find an installed XML parser");
|
|
};
|
|
|
|
|
|
/**
|
|
* XmlDocument factory
|
|
* @private
|
|
*/
|
|
function XmlDocument() {}
|
|
|
|
XmlDocument.create = function (name,ns) {
|
|
name = name || 'foo';
|
|
ns = ns || '';
|
|
|
|
try {
|
|
var doc;
|
|
// DOM2
|
|
if (document.implementation && document.implementation.createDocument) {
|
|
doc = document.implementation.createDocument(ns, name, null);
|
|
// some versions of Moz do not support the readyState property
|
|
// and the onreadystate event so we patch it!
|
|
if (doc.readyState == null) {
|
|
doc.readyState = 1;
|
|
doc.addEventListener("load", function () {
|
|
doc.readyState = 4;
|
|
if (typeof doc.onreadystatechange == "function")
|
|
doc.onreadystatechange();
|
|
}, false);
|
|
}
|
|
} else if (window.ActiveXObject) {
|
|
doc = new ActiveXObject(XmlDocument.getPrefix() + ".DomDocument");
|
|
}
|
|
|
|
if (!doc.documentElement || doc.documentElement.tagName != name ||
|
|
(doc.documentElement.namespaceURI &&
|
|
doc.documentElement.namespaceURI != ns)) {
|
|
try {
|
|
if (ns != '')
|
|
doc.appendChild(doc.createElement(name)).
|
|
setAttribute('xmlns',ns);
|
|
else
|
|
doc.appendChild(doc.createElement(name));
|
|
} catch (dex) {
|
|
doc = document.implementation.createDocument(ns,name,null);
|
|
|
|
if (doc.documentElement == null)
|
|
doc.appendChild(doc.createElement(name));
|
|
|
|
// fix buggy opera 8.5x
|
|
if (ns != '' &&
|
|
doc.documentElement.getAttribute('xmlns') != ns) {
|
|
doc.documentElement.setAttribute('xmlns',ns);
|
|
}
|
|
}
|
|
}
|
|
|
|
return doc;
|
|
}
|
|
catch (ex) { }
|
|
throw new Error("Your browser does not support XmlDocument objects");
|
|
};
|
|
|
|
/**
|
|
* used to find the Automation server name
|
|
* @private
|
|
*/
|
|
XmlDocument.getPrefix = function() {
|
|
if (XmlDocument.prefix)
|
|
return XmlDocument.prefix;
|
|
|
|
var prefixes = ["MSXML2", "Microsoft", "MSXML", "MSXML3"];
|
|
var o;
|
|
for (var i = 0; i < prefixes.length; i++) {
|
|
try {
|
|
// try to create the objects
|
|
o = new ActiveXObject(prefixes[i] + ".DomDocument");
|
|
return XmlDocument.prefix = prefixes[i];
|
|
}
|
|
catch (ex) {};
|
|
}
|
|
|
|
throw new Error("Could not find an installed XML parser");
|
|
};
|
|
|
|
|
|
// Create the loadXML method
|
|
if (typeof(Document) != 'undefined' && window.DOMParser) {
|
|
|
|
/**
|
|
* XMLDocument did not extend the Document interface in some
|
|
* versions of Mozilla.
|
|
* @private
|
|
*/
|
|
Document.prototype.loadXML = function (s) {
|
|
|
|
// parse the string to a new doc
|
|
var doc2 = (new DOMParser()).parseFromString(s, "text/xml");
|
|
|
|
// remove all initial children
|
|
while (this.hasChildNodes())
|
|
this.removeChild(this.lastChild);
|
|
|
|
// insert and import nodes
|
|
for (var i = 0; i < doc2.childNodes.length; i++) {
|
|
this.appendChild(this.importNode(doc2.childNodes[i], true));
|
|
}
|
|
};
|
|
}
|
|
|
|
// Create xml getter for Mozilla
|
|
if (window.XMLSerializer &&
|
|
window.Node && Node.prototype && Node.prototype.__defineGetter__) {
|
|
|
|
/**
|
|
* xml getter
|
|
*
|
|
* This serializes the DOM tree to an XML String
|
|
*
|
|
* Usage: var sXml = oNode.xml
|
|
* @deprecated
|
|
* @private
|
|
*/
|
|
// XMLDocument did not extend the Document interface in some versions
|
|
// of Mozilla. Extend both!
|
|
XMLDocument.prototype.__defineGetter__("xml", function () {
|
|
return (new XMLSerializer()).serializeToString(this);
|
|
});
|
|
/**
|
|
* xml getter
|
|
*
|
|
* This serializes the DOM tree to an XML String
|
|
*
|
|
* Usage: var sXml = oNode.xml
|
|
* @deprecated
|
|
* @private
|
|
*/
|
|
Document.prototype.__defineGetter__("xml", function () {
|
|
return (new XMLSerializer()).serializeToString(this);
|
|
});
|
|
|
|
/**
|
|
* xml getter
|
|
*
|
|
* This serializes the DOM tree to an XML String
|
|
*
|
|
* Usage: var sXml = oNode.xml
|
|
* @deprecated
|
|
* @private
|
|
*/
|
|
Node.prototype.__defineGetter__("xml", function () {
|
|
return (new XMLSerializer()).serializeToString(this);
|
|
});
|
|
}
|
|
|
|
|
|
/**
|
|
* @fileoverview Collection of functions to make live easier
|
|
* @author Stefan Strigler
|
|
* @version $Revision$
|
|
*/
|
|
|
|
/**
|
|
* Convert special chars to HTML entities
|
|
* @addon
|
|
* @return The string with chars encoded for HTML
|
|
* @type String
|
|
*/
|
|
String.prototype.htmlEnc = function() {
|
|
if(!this)
|
|
return this;
|
|
|
|
var str = this.replace(/&/g,"&");
|
|
str = str.replace(/</g,"<");
|
|
str = str.replace(/>/g,">");
|
|
str = str.replace(/\"/g,""");
|
|
str = str.replace(/\n/g,"<br />");
|
|
return str;
|
|
};
|
|
|
|
/**
|
|
* Convert HTML entities to special chars
|
|
* @addon
|
|
* @return The normal string
|
|
* @type String
|
|
*/
|
|
String.prototype.revertHtmlEnc = function() {
|
|
if(!this)
|
|
return this;
|
|
|
|
var str = this.replace(/&/gi,'&');
|
|
str = str.replace(/</gi,'<');
|
|
str = str.replace(/>/gi,'>');
|
|
str = str.replace(/"/gi,'\"');
|
|
str = str.replace(/<br( )?(\/)?>/gi,'\n');
|
|
return str;
|
|
};
|
|
|
|
/**
|
|
* Converts from jabber timestamps to JavaScript Date objects
|
|
* @addon
|
|
* @param {String} ts A string representing a jabber datetime timestamp as
|
|
* defined by {@link http://www.xmpp.org/extensions/xep-0082.html XEP-0082}
|
|
* @return A javascript Date object corresponding to the jabber DateTime given
|
|
* @type Date
|
|
*/
|
|
Date.jab2date = function(ts) {
|
|
// Get the UTC date
|
|
var date = new Date(Date.UTC(ts.substr(0,4),ts.substr(5,2)-1,ts.substr(8,2),ts.substr(11,2),ts.substr(14,2),ts.substr(17,2)));
|
|
|
|
if (ts.substr(ts.length-6,1) != 'Z') { // there's an offset
|
|
var date_offset = date.getTimezoneOffset() * 60 * 1000;
|
|
var offset = new Date();
|
|
offset.setTime(0);
|
|
offset.setUTCHours(ts.substr(ts.length-5,2));
|
|
offset.setUTCMinutes(ts.substr(ts.length-2,2));
|
|
if (ts.substr(ts.length-6,1) == '+')
|
|
date.setTime(date.getTime() + offset.getTime() + date_offset);
|
|
else if (ts.substr(ts.length-6,1) == '-')
|
|
date.setTime(date.getTime() - offset.getTime() + date_offset);
|
|
}
|
|
return date;
|
|
};
|
|
|
|
/**
|
|
* Takes a timestamp in the form of 2004-08-13T12:07:04+02:00 as argument
|
|
* and converts it to some sort of humane readable format
|
|
* @addon
|
|
*/
|
|
Date.hrTime = function(ts) {
|
|
return Date.jab2date(ts).toLocaleString();
|
|
};
|
|
|
|
/**
|
|
* somewhat opposit to {@link #hrTime}
|
|
* expects a javascript Date object as parameter and returns a jabber
|
|
* date string conforming to
|
|
* {@link http://www.xmpp.org/extensions/xep-0082.html XEP-0082}
|
|
* @see #hrTime
|
|
* @return The corresponding jabber DateTime string
|
|
* @type String
|
|
*/
|
|
Date.prototype.jabberDate = function() {
|
|
var padZero = function(i) {
|
|
if (i < 10) return "0" + i;
|
|
return i;
|
|
};
|
|
|
|
var jDate = this.getUTCFullYear() + "-";
|
|
jDate += padZero(this.getUTCMonth()+1) + "-";
|
|
jDate += padZero(this.getUTCDate()) + "T";
|
|
jDate += padZero(this.getUTCHours()) + ":";
|
|
jDate += padZero(this.getUTCMinutes()) + ":";
|
|
jDate += padZero(this.getUTCSeconds()) + "Z";
|
|
|
|
return jDate;
|
|
};
|
|
|
|
/**
|
|
* Determines the maximum of two given numbers
|
|
* @addon
|
|
* @param {Number} A a number
|
|
* @param {Number} B another number
|
|
* @return the maximum of A and B
|
|
* @type Number
|
|
*/
|
|
Number.max = function(A, B) {
|
|
return (A > B)? A : B;
|
|
};
|
|
|
|
Number.min = function(A, B) {
|
|
return (A < B)? A : B;
|
|
};
|
|
|
|
|
|
/* Copyright (c) 1998 - 2007, Paul Johnston & Contributors
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following
|
|
* disclaimer. Redistributions in binary form must reproduce the above
|
|
* copyright notice, this list of conditions and the following
|
|
* disclaimer in the documentation and/or other materials provided
|
|
* with the distribution.
|
|
*
|
|
* Neither the name of the author nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this
|
|
* software without specific prior written permission.
|
|
*
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
|
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
*/
|
|
|
|
/**
|
|
* @fileoverview Collection of MD5 and SHA1 hashing and encoding
|
|
* methods.
|
|
* @author Stefan Strigler steve@zeank.in-berlin.de
|
|
* @version $Revision$
|
|
*/
|
|
|
|
/*
|
|
* A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
|
|
* in FIPS PUB 180-1
|
|
* Version 2.1a Copyright Paul Johnston 2000 - 2002.
|
|
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
|
|
* Distributed under the BSD License
|
|
* See http://pajhome.org.uk/crypt/md5 for details.
|
|
*/
|
|
|
|
/*
|
|
* Configurable variables. You may need to tweak these to be compatible with
|
|
* the server-side, but the defaults work in most cases.
|
|
*/
|
|
var hexcase = 0; /* hex output format. 0 - lowercase; 1 - uppercase */
|
|
var b64pad = "="; /* base-64 pad character. "=" for strict RFC compliance */
|
|
var chrsz = 8; /* bits per input character. 8 - ASCII; 16 - Unicode */
|
|
|
|
/*
|
|
* These are the functions you'll usually want to call
|
|
* They take string arguments and return either hex or base-64 encoded strings
|
|
*/
|
|
function hex_sha1(s){return binb2hex(core_sha1(str2binb(s),s.length * chrsz));}
|
|
function b64_sha1(s){return binb2b64(core_sha1(str2binb(s),s.length * chrsz));}
|
|
function str_sha1(s){return binb2str(core_sha1(str2binb(s),s.length * chrsz));}
|
|
function hex_hmac_sha1(key, data){ return binb2hex(core_hmac_sha1(key, data));}
|
|
function b64_hmac_sha1(key, data){ return binb2b64(core_hmac_sha1(key, data));}
|
|
function str_hmac_sha1(key, data){ return binb2str(core_hmac_sha1(key, data));}
|
|
|
|
/*
|
|
* Perform a simple self-test to see if the VM is working
|
|
*/
|
|
function sha1_vm_test()
|
|
{
|
|
return hex_sha1("abc") == "a9993e364706816aba3e25717850c26c9cd0d89d";
|
|
}
|
|
|
|
/*
|
|
* Calculate the SHA-1 of an array of big-endian words, and a bit length
|
|
*/
|
|
function core_sha1(x, len)
|
|
{
|
|
/* append padding */
|
|
x[len >> 5] |= 0x80 << (24 - len % 32);
|
|
x[((len + 64 >> 9) << 4) + 15] = len;
|
|
|
|
var w = Array(80);
|
|
var a = 1732584193;
|
|
var b = -271733879;
|
|
var c = -1732584194;
|
|
var d = 271733878;
|
|
var e = -1009589776;
|
|
|
|
for(var i = 0; i < x.length; i += 16)
|
|
{
|
|
var olda = a;
|
|
var oldb = b;
|
|
var oldc = c;
|
|
var oldd = d;
|
|
var olde = e;
|
|
|
|
for(var j = 0; j < 80; j++)
|
|
{
|
|
if(j < 16) w[j] = x[i + j];
|
|
else w[j] = rol(w[j-3] ^ w[j-8] ^ w[j-14] ^ w[j-16], 1);
|
|
var t = safe_add(safe_add(rol(a, 5), sha1_ft(j, b, c, d)),
|
|
safe_add(safe_add(e, w[j]), sha1_kt(j)));
|
|
e = d;
|
|
d = c;
|
|
c = rol(b, 30);
|
|
b = a;
|
|
a = t;
|
|
}
|
|
|
|
a = safe_add(a, olda);
|
|
b = safe_add(b, oldb);
|
|
c = safe_add(c, oldc);
|
|
d = safe_add(d, oldd);
|
|
e = safe_add(e, olde);
|
|
}
|
|
return Array(a, b, c, d, e);
|
|
|
|
}
|
|
|
|
/*
|
|
* Perform the appropriate triplet combination function for the current
|
|
* iteration
|
|
*/
|
|
function sha1_ft(t, b, c, d)
|
|
{
|
|
if(t < 20) return (b & c) | ((~b) & d);
|
|
if(t < 40) return b ^ c ^ d;
|
|
if(t < 60) return (b & c) | (b & d) | (c & d);
|
|
return b ^ c ^ d;
|
|
}
|
|
|
|
/*
|
|
* Determine the appropriate additive constant for the current iteration
|
|
*/
|
|
function sha1_kt(t)
|
|
{
|
|
return (t < 20) ? 1518500249 : (t < 40) ? 1859775393 :
|
|
(t < 60) ? -1894007588 : -899497514;
|
|
}
|
|
|
|
/*
|
|
* Calculate the HMAC-SHA1 of a key and some data
|
|
*/
|
|
function core_hmac_sha1(key, data)
|
|
{
|
|
var bkey = str2binb(key);
|
|
if(bkey.length > 16) bkey = core_sha1(bkey, key.length * chrsz);
|
|
|
|
var ipad = Array(16), opad = Array(16);
|
|
for(var i = 0; i < 16; i++)
|
|
{
|
|
ipad[i] = bkey[i] ^ 0x36363636;
|
|
opad[i] = bkey[i] ^ 0x5C5C5C5C;
|
|
}
|
|
|
|
var hash = core_sha1(ipad.concat(str2binb(data)), 512 + data.length * chrsz);
|
|
return core_sha1(opad.concat(hash), 512 + 160);
|
|
}
|
|
|
|
/*
|
|
* Bitwise rotate a 32-bit number to the left.
|
|
*/
|
|
function rol(num, cnt)
|
|
{
|
|
return (num << cnt) | (num >>> (32 - cnt));
|
|
}
|
|
|
|
/*
|
|
* Convert an 8-bit or 16-bit string to an array of big-endian words
|
|
* In 8-bit function, characters >255 have their hi-byte silently ignored.
|
|
*/
|
|
function str2binb(str)
|
|
{
|
|
var bin = Array();
|
|
var mask = (1 << chrsz) - 1;
|
|
for(var i = 0; i < str.length * chrsz; i += chrsz)
|
|
bin[i>>5] |= (str.charCodeAt(i / chrsz) & mask) << (32 - chrsz - i%32);
|
|
return bin;
|
|
}
|
|
|
|
/*
|
|
* Convert an array of big-endian words to a string
|
|
*/
|
|
function binb2str(bin)
|
|
{
|
|
var str = "";
|
|
var mask = (1 << chrsz) - 1;
|
|
for(var i = 0; i < bin.length * 32; i += chrsz)
|
|
str += String.fromCharCode((bin[i>>5] >>> (32 - chrsz - i%32)) & mask);
|
|
return str;
|
|
}
|
|
|
|
/*
|
|
* Convert an array of big-endian words to a hex string.
|
|
*/
|
|
function binb2hex(binarray)
|
|
{
|
|
var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
|
|
var str = "";
|
|
for(var i = 0; i < binarray.length * 4; i++)
|
|
{
|
|
str += hex_tab.charAt((binarray[i>>2] >> ((3 - i%4)*8+4)) & 0xF) +
|
|
hex_tab.charAt((binarray[i>>2] >> ((3 - i%4)*8 )) & 0xF);
|
|
}
|
|
return str;
|
|
}
|
|
|
|
/*
|
|
* Convert an array of big-endian words to a base-64 string
|
|
*/
|
|
function binb2b64(binarray)
|
|
{
|
|
var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
var str = "";
|
|
for(var i = 0; i < binarray.length * 4; i += 3)
|
|
{
|
|
var triplet = (((binarray[i >> 2] >> 8 * (3 - i %4)) & 0xFF) << 16)
|
|
| (((binarray[i+1 >> 2] >> 8 * (3 - (i+1)%4)) & 0xFF) << 8 )
|
|
| ((binarray[i+2 >> 2] >> 8 * (3 - (i+2)%4)) & 0xFF);
|
|
for(var j = 0; j < 4; j++)
|
|
{
|
|
if(i * 8 + j * 6 > binarray.length * 32) str += b64pad;
|
|
else str += tab.charAt((triplet >> 6*(3-j)) & 0x3F);
|
|
}
|
|
}
|
|
return str.replace(/AAA\=(\=*?)$/,'$1'); // cleans garbage chars at end of string
|
|
}
|
|
|
|
/*
|
|
* A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
|
|
* Digest Algorithm, as defined in RFC 1321.
|
|
* Version 2.1 Copyright (C) Paul Johnston 1999 - 2002.
|
|
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
|
|
* Distributed under the BSD License
|
|
* See http://pajhome.org.uk/crypt/md5 for more info.
|
|
*/
|
|
|
|
/*
|
|
* Configurable variables. You may need to tweak these to be compatible with
|
|
* the server-side, but the defaults work in most cases.
|
|
*/
|
|
// var hexcase = 0; /* hex output format. 0 - lowercase; 1 - uppercase */
|
|
// var b64pad = ""; /* base-64 pad character. "=" for strict RFC compliance */
|
|
// var chrsz = 8; /* bits per input character. 8 - ASCII; 16 - Unicode */
|
|
|
|
/*
|
|
* These are the functions you'll usually want to call
|
|
* They take string arguments and return either hex or base-64 encoded strings
|
|
*/
|
|
function hex_md5(s){ return binl2hex(core_md5(str2binl(s), s.length * chrsz));}
|
|
function b64_md5(s){ return binl2b64(core_md5(str2binl(s), s.length * chrsz));}
|
|
function str_md5(s){ return binl2str(core_md5(str2binl(s), s.length * chrsz));}
|
|
function hex_hmac_md5(key, data) { return binl2hex(core_hmac_md5(key, data)); }
|
|
function b64_hmac_md5(key, data) { return binl2b64(core_hmac_md5(key, data)); }
|
|
function str_hmac_md5(key, data) { return binl2str(core_hmac_md5(key, data)); }
|
|
|
|
/*
|
|
* Perform a simple self-test to see if the VM is working
|
|
*/
|
|
function md5_vm_test()
|
|
{
|
|
return hex_md5("abc") == "900150983cd24fb0d6963f7d28e17f72";
|
|
}
|
|
|
|
/*
|
|
* Calculate the MD5 of an array of little-endian words, and a bit length
|
|
*/
|
|
function core_md5(x, len)
|
|
{
|
|
/* append padding */
|
|
x[len >> 5] |= 0x80 << ((len) % 32);
|
|
x[(((len + 64) >>> 9) << 4) + 14] = len;
|
|
|
|
var a = 1732584193;
|
|
var b = -271733879;
|
|
var c = -1732584194;
|
|
var d = 271733878;
|
|
|
|
for(var i = 0; i < x.length; i += 16)
|
|
{
|
|
var olda = a;
|
|
var oldb = b;
|
|
var oldc = c;
|
|
var oldd = d;
|
|
|
|
a = md5_ff(a, b, c, d, x[i+ 0], 7 , -680876936);
|
|
d = md5_ff(d, a, b, c, x[i+ 1], 12, -389564586);
|
|
c = md5_ff(c, d, a, b, x[i+ 2], 17, 606105819);
|
|
b = md5_ff(b, c, d, a, x[i+ 3], 22, -1044525330);
|
|
a = md5_ff(a, b, c, d, x[i+ 4], 7 , -176418897);
|
|
d = md5_ff(d, a, b, c, x[i+ 5], 12, 1200080426);
|
|
c = md5_ff(c, d, a, b, x[i+ 6], 17, -1473231341);
|
|
b = md5_ff(b, c, d, a, x[i+ 7], 22, -45705983);
|
|
a = md5_ff(a, b, c, d, x[i+ 8], 7 , 1770035416);
|
|
d = md5_ff(d, a, b, c, x[i+ 9], 12, -1958414417);
|
|
c = md5_ff(c, d, a, b, x[i+10], 17, -42063);
|
|
b = md5_ff(b, c, d, a, x[i+11], 22, -1990404162);
|
|
a = md5_ff(a, b, c, d, x[i+12], 7 , 1804603682);
|
|
d = md5_ff(d, a, b, c, x[i+13], 12, -40341101);
|
|
c = md5_ff(c, d, a, b, x[i+14], 17, -1502002290);
|
|
b = md5_ff(b, c, d, a, x[i+15], 22, 1236535329);
|
|
|
|
a = md5_gg(a, b, c, d, x[i+ 1], 5 , -165796510);
|
|
d = md5_gg(d, a, b, c, x[i+ 6], 9 , -1069501632);
|
|
c = md5_gg(c, d, a, b, x[i+11], 14, 643717713);
|
|
b = md5_gg(b, c, d, a, x[i+ 0], 20, -373897302);
|
|
a = md5_gg(a, b, c, d, x[i+ 5], 5 , -701558691);
|
|
d = md5_gg(d, a, b, c, x[i+10], 9 , 38016083);
|
|
c = md5_gg(c, d, a, b, x[i+15], 14, -660478335);
|
|
b = md5_gg(b, c, d, a, x[i+ 4], 20, -405537848);
|
|
a = md5_gg(a, b, c, d, x[i+ 9], 5 , 568446438);
|
|
d = md5_gg(d, a, b, c, x[i+14], 9 , -1019803690);
|
|
c = md5_gg(c, d, a, b, x[i+ 3], 14, -187363961);
|
|
b = md5_gg(b, c, d, a, x[i+ 8], 20, 1163531501);
|
|
a = md5_gg(a, b, c, d, x[i+13], 5 , -1444681467);
|
|
d = md5_gg(d, a, b, c, x[i+ 2], 9 , -51403784);
|
|
c = md5_gg(c, d, a, b, x[i+ 7], 14, 1735328473);
|
|
b = md5_gg(b, c, d, a, x[i+12], 20, -1926607734);
|
|
|
|
a = md5_hh(a, b, c, d, x[i+ 5], 4 , -378558);
|
|
d = md5_hh(d, a, b, c, x[i+ 8], 11, -2022574463);
|
|
c = md5_hh(c, d, a, b, x[i+11], 16, 1839030562);
|
|
b = md5_hh(b, c, d, a, x[i+14], 23, -35309556);
|
|
a = md5_hh(a, b, c, d, x[i+ 1], 4 , -1530992060);
|
|
d = md5_hh(d, a, b, c, x[i+ 4], 11, 1272893353);
|
|
c = md5_hh(c, d, a, b, x[i+ 7], 16, -155497632);
|
|
b = md5_hh(b, c, d, a, x[i+10], 23, -1094730640);
|
|
a = md5_hh(a, b, c, d, x[i+13], 4 , 681279174);
|
|
d = md5_hh(d, a, b, c, x[i+ 0], 11, -358537222);
|
|
c = md5_hh(c, d, a, b, x[i+ 3], 16, -722521979);
|
|
b = md5_hh(b, c, d, a, x[i+ 6], 23, 76029189);
|
|
a = md5_hh(a, b, c, d, x[i+ 9], 4 , -640364487);
|
|
d = md5_hh(d, a, b, c, x[i+12], 11, -421815835);
|
|
c = md5_hh(c, d, a, b, x[i+15], 16, 530742520);
|
|
b = md5_hh(b, c, d, a, x[i+ 2], 23, -995338651);
|
|
|
|
a = md5_ii(a, b, c, d, x[i+ 0], 6 , -198630844);
|
|
d = md5_ii(d, a, b, c, x[i+ 7], 10, 1126891415);
|
|
c = md5_ii(c, d, a, b, x[i+14], 15, -1416354905);
|
|
b = md5_ii(b, c, d, a, x[i+ 5], 21, -57434055);
|
|
a = md5_ii(a, b, c, d, x[i+12], 6 , 1700485571);
|
|
d = md5_ii(d, a, b, c, x[i+ 3], 10, -1894986606);
|
|
c = md5_ii(c, d, a, b, x[i+10], 15, -1051523);
|
|
b = md5_ii(b, c, d, a, x[i+ 1], 21, -2054922799);
|
|
a = md5_ii(a, b, c, d, x[i+ 8], 6 , 1873313359);
|
|
d = md5_ii(d, a, b, c, x[i+15], 10, -30611744);
|
|
c = md5_ii(c, d, a, b, x[i+ 6], 15, -1560198380);
|
|
b = md5_ii(b, c, d, a, x[i+13], 21, 1309151649);
|
|
a = md5_ii(a, b, c, d, x[i+ 4], 6 , -145523070);
|
|
d = md5_ii(d, a, b, c, x[i+11], 10, -1120210379);
|
|
c = md5_ii(c, d, a, b, x[i+ 2], 15, 718787259);
|
|
b = md5_ii(b, c, d, a, x[i+ 9], 21, -343485551);
|
|
|
|
a = safe_add(a, olda);
|
|
b = safe_add(b, oldb);
|
|
c = safe_add(c, oldc);
|
|
d = safe_add(d, oldd);
|
|
}
|
|
return Array(a, b, c, d);
|
|
|
|
}
|
|
|
|
/*
|
|
* These functions implement the four basic operations the algorithm uses.
|
|
*/
|
|
function md5_cmn(q, a, b, x, s, t)
|
|
{
|
|
return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s),b);
|
|
}
|
|
function md5_ff(a, b, c, d, x, s, t)
|
|
{
|
|
return md5_cmn((b & c) | ((~b) & d), a, b, x, s, t);
|
|
}
|
|
function md5_gg(a, b, c, d, x, s, t)
|
|
{
|
|
return md5_cmn((b & d) | (c & (~d)), a, b, x, s, t);
|
|
}
|
|
function md5_hh(a, b, c, d, x, s, t)
|
|
{
|
|
return md5_cmn(b ^ c ^ d, a, b, x, s, t);
|
|
}
|
|
function md5_ii(a, b, c, d, x, s, t)
|
|
{
|
|
return md5_cmn(c ^ (b | (~d)), a, b, x, s, t);
|
|
}
|
|
|
|
/*
|
|
* Calculate the HMAC-MD5, of a key and some data
|
|
*/
|
|
function core_hmac_md5(key, data)
|
|
{
|
|
var bkey = str2binl(key);
|
|
if(bkey.length > 16) bkey = core_md5(bkey, key.length * chrsz);
|
|
|
|
var ipad = Array(16), opad = Array(16);
|
|
for(var i = 0; i < 16; i++)
|
|
{
|
|
ipad[i] = bkey[i] ^ 0x36363636;
|
|
opad[i] = bkey[i] ^ 0x5C5C5C5C;
|
|
}
|
|
|
|
var hash = core_md5(ipad.concat(str2binl(data)), 512 + data.length * chrsz);
|
|
return core_md5(opad.concat(hash), 512 + 128);
|
|
}
|
|
|
|
/*
|
|
* Add integers, wrapping at 2^32. This uses 16-bit operations internally
|
|
* to work around bugs in some JS interpreters.
|
|
*/
|
|
function safe_add(x, y)
|
|
{
|
|
var lsw = (x & 0xFFFF) + (y & 0xFFFF);
|
|
var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
|
|
return (msw << 16) | (lsw & 0xFFFF);
|
|
}
|
|
|
|
/*
|
|
* Bitwise rotate a 32-bit number to the left.
|
|
*/
|
|
function bit_rol(num, cnt)
|
|
{
|
|
return (num << cnt) | (num >>> (32 - cnt));
|
|
}
|
|
|
|
/*
|
|
* Convert a string to an array of little-endian words
|
|
* If chrsz is ASCII, characters >255 have their hi-byte silently ignored.
|
|
*/
|
|
function str2binl(str)
|
|
{
|
|
var bin = Array();
|
|
var mask = (1 << chrsz) - 1;
|
|
for(var i = 0; i < str.length * chrsz; i += chrsz)
|
|
bin[i>>5] |= (str.charCodeAt(i / chrsz) & mask) << (i%32);
|
|
return bin;
|
|
}
|
|
|
|
/*
|
|
* Convert an array of little-endian words to a string
|
|
*/
|
|
function binl2str(bin)
|
|
{
|
|
var str = "";
|
|
var mask = (1 << chrsz) - 1;
|
|
for(var i = 0; i < bin.length * 32; i += chrsz)
|
|
str += String.fromCharCode((bin[i>>5] >>> (i % 32)) & mask);
|
|
return str;
|
|
}
|
|
|
|
/*
|
|
* Convert an array of little-endian words to a hex string.
|
|
*/
|
|
function binl2hex(binarray)
|
|
{
|
|
var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
|
|
var str = "";
|
|
for(var i = 0; i < binarray.length * 4; i++)
|
|
{
|
|
str += hex_tab.charAt((binarray[i>>2] >> ((i%4)*8+4)) & 0xF) +
|
|
hex_tab.charAt((binarray[i>>2] >> ((i%4)*8 )) & 0xF);
|
|
}
|
|
return str;
|
|
}
|
|
|
|
/*
|
|
* Convert an array of little-endian words to a base-64 string
|
|
*/
|
|
function binl2b64(binarray)
|
|
{
|
|
var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
var str = "";
|
|
for(var i = 0; i < binarray.length * 4; i += 3)
|
|
{
|
|
var triplet = (((binarray[i >> 2] >> 8 * ( i %4)) & 0xFF) << 16)
|
|
| (((binarray[i+1 >> 2] >> 8 * ((i+1)%4)) & 0xFF) << 8 )
|
|
| ((binarray[i+2 >> 2] >> 8 * ((i+2)%4)) & 0xFF);
|
|
for(var j = 0; j < 4; j++)
|
|
{
|
|
if(i * 8 + j * 6 > binarray.length * 32) str += b64pad;
|
|
else str += tab.charAt((triplet >> 6*(3-j)) & 0x3F);
|
|
}
|
|
}
|
|
return str;
|
|
}
|
|
|
|
/* #############################################################################
|
|
UTF-8 Decoder and Encoder
|
|
base64 Encoder and Decoder
|
|
written by Tobias Kieslich, justdreams
|
|
Contact: tobias@justdreams.de http://www.justdreams.de/
|
|
############################################################################# */
|
|
|
|
// returns an array of byterepresenting dezimal numbers which represent the
|
|
// plaintext in an UTF-8 encoded version. Expects a string.
|
|
// This function includes an exception management for those nasty browsers like
|
|
// NN401, which returns negative decimal numbers for chars>128. I hate it!!
|
|
// This handling is unfortunately limited to the user's charset. Anyway, it works
|
|
// in most of the cases! Special signs with an unicode>256 return numbers, which
|
|
// can not be converted to the actual unicode and so not to the valid utf-8
|
|
// representation. Anyway, this function does always return values which can not
|
|
// misinterpretd by RC4 or base64 en- or decoding, because every value is >0 and
|
|
// <255!!
|
|
// Arrays are faster and easier to handle in b64 encoding or encrypting....
|
|
function utf8t2d(t)
|
|
{
|
|
t = t.replace(/\r\n/g,"\n");
|
|
var d=new Array; var test=String.fromCharCode(237);
|
|
if (test.charCodeAt(0) < 0)
|
|
for(var n=0; n<t.length; n++)
|
|
{
|
|
var c=t.charCodeAt(n);
|
|
if (c>0)
|
|
d[d.length]= c;
|
|
else {
|
|
d[d.length]= (((256+c)>>6)|192);
|
|
d[d.length]= (((256+c)&63)|128);}
|
|
}
|
|
else
|
|
for(var n=0; n<t.length; n++)
|
|
{
|
|
var c=t.charCodeAt(n);
|
|
// all the signs of asci => 1byte
|
|
if (c<128)
|
|
d[d.length]= c;
|
|
// all the signs between 127 and 2047 => 2byte
|
|
else if((c>127) && (c<2048)) {
|
|
d[d.length]= ((c>>6)|192);
|
|
d[d.length]= ((c&63)|128);}
|
|
// all the signs between 2048 and 66536 => 3byte
|
|
else {
|
|
d[d.length]= ((c>>12)|224);
|
|
d[d.length]= (((c>>6)&63)|128);
|
|
d[d.length]= ((c&63)|128);}
|
|
}
|
|
return d;
|
|
}
|
|
|
|
// returns plaintext from an array of bytesrepresenting dezimal numbers, which
|
|
// represent an UTF-8 encoded text; browser which does not understand unicode
|
|
// like NN401 will show "?"-signs instead
|
|
// expects an array of byterepresenting decimals; returns a string
|
|
function utf8d2t(d)
|
|
{
|
|
var r=new Array; var i=0;
|
|
while(i<d.length)
|
|
{
|
|
if (d[i]<128) {
|
|
r[r.length]= String.fromCharCode(d[i]); i++;}
|
|
else if((d[i]>191) && (d[i]<224)) {
|
|
r[r.length]= String.fromCharCode(((d[i]&31)<<6) | (d[i+1]&63)); i+=2;}
|
|
else {
|
|
r[r.length]= String.fromCharCode(((d[i]&15)<<12) | ((d[i+1]&63)<<6) | (d[i+2]&63)); i+=3;}
|
|
}
|
|
return r.join("");
|
|
}
|
|
|
|
// included in <body onload="b64arrays"> it creates two arrays which makes base64
|
|
// en- and decoding faster
|
|
// this speed is noticeable especially when coding larger texts (>5k or so)
|
|
function b64arrays() {
|
|
var b64s='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
|
|
b64 = new Array();f64 =new Array();
|
|
for (var i=0; i<b64s.length ;i++) {
|
|
b64[i] = b64s.charAt(i);
|
|
f64[b64s.charAt(i)] = i;
|
|
}
|
|
}
|
|
|
|
// creates a base64 encoded text out of an array of byerepresenting dezimals
|
|
// it is really base64 :) this makes serversided handling easier
|
|
// expects an array; returns a string
|
|
function b64d2t(d) {
|
|
var r=new Array; var i=0; var dl=d.length;
|
|
// this is for the padding
|
|
if ((dl%3) == 1) {
|
|
d[d.length] = 0; d[d.length] = 0;}
|
|
if ((dl%3) == 2)
|
|
d[d.length] = 0;
|
|
// from here conversion
|
|
while (i<d.length)
|
|
{
|
|
r[r.length] = b64[d[i]>>2];
|
|
r[r.length] = b64[((d[i]&3)<<4) | (d[i+1]>>4)];
|
|
r[r.length] = b64[((d[i+1]&15)<<2) | (d[i+2]>>6)];
|
|
r[r.length] = b64[d[i+2]&63];
|
|
i+=3;
|
|
}
|
|
// this is again for the padding
|
|
if ((dl%3) == 1)
|
|
r[r.length-1] = r[r.length-2] = "=";
|
|
if ((dl%3) == 2)
|
|
r[r.length-1] = "=";
|
|
// we join the array to return a textstring
|
|
var t=r.join("");
|
|
return t;
|
|
}
|
|
|
|
// returns array of byterepresenting numbers created of an base64 encoded text
|
|
// it is still the slowest function in this modul; I hope I can make it faster
|
|
// expects string; returns an array
|
|
function b64t2d(t) {
|
|
var d=new Array; var i=0;
|
|
// here we fix this CRLF sequenz created by MS-OS; arrrgh!!!
|
|
t=t.replace(/\n|\r/g,""); t=t.replace(/=/g,"");
|
|
while (i<t.length)
|
|
{
|
|
d[d.length] = (f64[t.charAt(i)]<<2) | (f64[t.charAt(i+1)]>>4);
|
|
d[d.length] = (((f64[t.charAt(i+1)]&15)<<4) | (f64[t.charAt(i+2)]>>2));
|
|
d[d.length] = (((f64[t.charAt(i+2)]&3)<<6) | (f64[t.charAt(i+3)]));
|
|
i+=4;
|
|
}
|
|
if (t.length%4 == 2)
|
|
d = d.slice(0, d.length-2);
|
|
if (t.length%4 == 3)
|
|
d = d.slice(0, d.length-1);
|
|
return d;
|
|
}
|
|
|
|
b64arrays();
|
|
|
|
b64decode = function(s) {
|
|
return utf8d2t(b64t2d(s));
|
|
}
|
|
|
|
b64encode = function(s) {
|
|
return b64d2t(utf8t2d(s));
|
|
}
|
|
|
|
function cnonce(size) {
|
|
var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
|
|
var cnonce = '';
|
|
for (var i=0; i<size; i++) {
|
|
cnonce += tab.charAt(Math.round(Math.random(new Date().getTime())*(tab.length-1)));
|
|
}
|
|
return cnonce;
|
|
}
|
|
|
|
|
|
|
|
JSJAC_HAVEKEYS = true; // whether to use keys
|
|
JSJAC_NKEYS = 16; // number of keys to generate
|
|
JSJAC_INACTIVITY = 300; // qnd hack to make suspend/resume
|
|
// work more smoothly with polling
|
|
JSJAC_ERR_COUNT = 10; // number of retries in case of connection
|
|
// errors
|
|
|
|
JSJAC_ALLOW_PLAIN = true; // whether to allow plaintext logins
|
|
|
|
JSJAC_CHECKQUEUEINTERVAL = 100; // msecs to poll send queue
|
|
JSJAC_CHECKINQUEUEINTERVAL = 100; // msecs to poll incoming queue
|
|
JSJAC_TIMERVAL = 2000; // default polling interval
|
|
|
|
// Options specific to HTTP Binding (BOSH)
|
|
JSJACHBC_MAX_HOLD = 1; // default for number of connections held by
|
|
// connection manager
|
|
JSJACHBC_MAX_WAIT = 20; // default 'wait' param - how long an idle connection
|
|
// should be held by connection manager
|
|
|
|
JSJACHBC_BOSH_VERSION = "1.6";
|
|
JSJACHBC_USE_BOSH_VER = true;
|
|
|
|
JSJACHBC_MAXPAUSE = 20; // how long a suspend/resume cycle may take
|
|
|
|
/*** END CONFIG ***/
|
|
|
|
|
|
/* Copyright (c) 2005-2007 Sam Stephenson
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person
|
|
* obtaining a copy of this software and associated documentation
|
|
* files (the "Software"), to deal in the Software without
|
|
* restriction, including without limitation the rights to use, copy,
|
|
* modify, merge, publish, distribute, sublicense, and/or sell copies
|
|
* of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
/*
|
|
json.js
|
|
taken from prototype.js, made static
|
|
*/
|
|
function JSJaCJSON() {}
|
|
JSJaCJSON.toString = function (obj) {
|
|
var m = {
|
|
'\b': '\\b',
|
|
'\t': '\\t',
|
|
'\n': '\\n',
|
|
'\f': '\\f',
|
|
'\r': '\\r',
|
|
'"' : '\\"',
|
|
'\\': '\\\\'
|
|
},
|
|
s = {
|
|
array: function (x) {
|
|
var a = ['['], b, f, i, l = x.length, v;
|
|
for (i = 0; i < l; i += 1) {
|
|
v = x[i];
|
|
f = s[typeof v];
|
|
if (f) {
|
|
try {
|
|
v = f(v);
|
|
if (typeof v == 'string') {
|
|
if (b) {
|
|
a[a.length] = ',';
|
|
}
|
|
a[a.length] = v;
|
|
b = true;
|
|
}
|
|
} catch(e) {
|
|
}
|
|
}
|
|
}
|
|
a[a.length] = ']';
|
|
return a.join('');
|
|
},
|
|
'boolean': function (x) {
|
|
return String(x);
|
|
},
|
|
'null': function (x) {
|
|
return "null";
|
|
},
|
|
number: function (x) {
|
|
return isFinite(x) ? String(x) : 'null';
|
|
},
|
|
object: function (x) {
|
|
if (x) {
|
|
if (x instanceof Array) {
|
|
return s.array(x);
|
|
}
|
|
var a = ['{'], b, f, i, v;
|
|
for (i in x) {
|
|
if (x.hasOwnProperty(i)) {
|
|
v = x[i];
|
|
f = s[typeof v];
|
|
if (f) {
|
|
try {
|
|
v = f(v);
|
|
if (typeof v == 'string') {
|
|
if (b) {
|
|
a[a.length] = ',';
|
|
}
|
|
a.push(s.string(i), ':', v);
|
|
b = true;
|
|
}
|
|
} catch(e) {
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
a[a.length] = '}';
|
|
return a.join('');
|
|
}
|
|
return 'null';
|
|
},
|
|
string: function (x) {
|
|
if (/["\\\x00-\x1f]/.test(x)) {
|
|
x = x.replace(/([\x00-\x1f\\"])/g, function(a, b) {
|
|
var c = m[b];
|
|
if (c) {
|
|
return c;
|
|
}
|
|
c = b.charCodeAt();
|
|
return '\\u00' +
|
|
Math.floor(c / 16).toString(16) +
|
|
(c % 16).toString(16);
|
|
});
|
|
}
|
|
return '"' + x + '"';
|
|
}
|
|
};
|
|
|
|
switch (typeof(obj)) {
|
|
case 'object':
|
|
return s.object(obj);
|
|
case 'array':
|
|
return s.array(obj);
|
|
|
|
}
|
|
};
|
|
|
|
JSJaCJSON.parse = function (str) {
|
|
try {
|
|
return !(/[^,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]/.test(
|
|
str.replace(/"(\\.|[^"\\])*"/g, ''))) &&
|
|
eval('(' + str + ')');
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* @fileoverview This file contains all things that make life easier when
|
|
* dealing with JIDs
|
|
* @author Stefan Strigler
|
|
* @version $Revision$
|
|
*/
|
|
|
|
/**
|
|
* list of forbidden chars for nodenames
|
|
* @private
|
|
*/
|
|
var JSJACJID_FORBIDDEN = ['"',' ','&','\'','/',':','<','>','@'];
|
|
|
|
/**
|
|
* Creates a new JSJaCJID object
|
|
* @class JSJaCJID models xmpp jid objects
|
|
* @constructor
|
|
* @param {Object} jid jid may be either of type String or a JID represented
|
|
* by JSON with fields 'node', 'domain' and 'resource'
|
|
* @throws JSJaCJIDInvalidException Thrown if jid is not valid
|
|
* @return a new JSJaCJID object
|
|
*/
|
|
function JSJaCJID(jid) {
|
|
/**
|
|
*@private
|
|
*/
|
|
this._node = '';
|
|
/**
|
|
*@private
|
|
*/
|
|
this._domain = '';
|
|
/**
|
|
*@private
|
|
*/
|
|
this._resource = '';
|
|
|
|
if (typeof(jid) == 'string') {
|
|
if (jid.indexOf('@') != -1) {
|
|
this.setNode(jid.substring(0,jid.indexOf('@')));
|
|
jid = jid.substring(jid.indexOf('@')+1);
|
|
}
|
|
if (jid.indexOf('/') != -1) {
|
|
this.setResource(jid.substring(jid.indexOf('/')+1));
|
|
jid = jid.substring(0,jid.indexOf('/'));
|
|
}
|
|
this.setDomain(jid);
|
|
} else {
|
|
this.setNode(jid.node);
|
|
this.setDomain(jid.domain);
|
|
this.setResource(jid.resource);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Gets the node part of the jid
|
|
* @return A string representing the node name
|
|
* @type String
|
|
*/
|
|
JSJaCJID.prototype.getNode = function() { return this._node; };
|
|
|
|
/**
|
|
* Gets the domain part of the jid
|
|
* @return A string representing the domain name
|
|
* @type String
|
|
*/
|
|
JSJaCJID.prototype.getDomain = function() { return this._domain; };
|
|
|
|
/**
|
|
* Gets the resource part of the jid
|
|
* @return A string representing the resource
|
|
* @type String
|
|
*/
|
|
JSJaCJID.prototype.getResource = function() { return this._resource; };
|
|
|
|
|
|
/**
|
|
* Sets the node part of the jid
|
|
* @param {String} node Name of the node
|
|
* @throws JSJaCJIDInvalidException Thrown if node name contains invalid chars
|
|
* @return This object
|
|
* @type JSJaCJID
|
|
*/
|
|
JSJaCJID.prototype.setNode = function(node) {
|
|
JSJaCJID._checkNodeName(node);
|
|
this._node = node || '';
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Sets the domain part of the jid
|
|
* @param {String} domain Name of the domain
|
|
* @throws JSJaCJIDInvalidException Thrown if domain name contains invalid
|
|
* chars or is empty
|
|
* @return This object
|
|
* @type JSJaCJID
|
|
*/
|
|
JSJaCJID.prototype.setDomain = function(domain) {
|
|
if (!domain || domain == '')
|
|
throw new JSJaCJIDInvalidException("domain name missing");
|
|
// chars forbidden for a node are not allowed in domain names
|
|
// anyway, so let's check
|
|
JSJaCJID._checkNodeName(domain);
|
|
this._domain = domain;
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Sets the resource part of the jid
|
|
* @param {String} resource Name of the resource
|
|
* @return This object
|
|
* @type JSJaCJID
|
|
*/
|
|
JSJaCJID.prototype.setResource = function(resource) {
|
|
this._resource = resource || '';
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* The string representation of the full jid
|
|
* @return A string representing the jid
|
|
* @type String
|
|
*/
|
|
JSJaCJID.prototype.toString = function() {
|
|
var jid = '';
|
|
if (this.getNode() && this.getNode() != '')
|
|
jid = this.getNode() + '@';
|
|
jid += this.getDomain(); // we always have a domain
|
|
if (this.getResource() && this.getResource() != "")
|
|
jid += '/' + this.getResource();
|
|
return jid;
|
|
};
|
|
|
|
/**
|
|
* Removes the resource part of the jid
|
|
* @return This object
|
|
* @type JSJaCJID
|
|
*/
|
|
JSJaCJID.prototype.removeResource = function() {
|
|
return this.setResource();
|
|
};
|
|
|
|
/**
|
|
* creates a copy of this JSJaCJID object
|
|
* @return A copy of this
|
|
* @type JSJaCJID
|
|
*/
|
|
JSJaCJID.prototype.clone = function() {
|
|
return new JSJaCJID(this.toString());
|
|
};
|
|
|
|
/**
|
|
* Compares two jids if they belong to the same entity (i.e. w/o resource)
|
|
* @param {String} jid a jid as string or JSJaCJID object
|
|
* @return 'true' if jid is same entity as this
|
|
* @type Boolean
|
|
*/
|
|
JSJaCJID.prototype.isEntity = function(jid) {
|
|
if (typeof jid == 'string')
|
|
jid = (new JSJaCJID(jid));
|
|
jid.removeResource();
|
|
return (this.clone().removeResource().toString() === jid.toString());
|
|
};
|
|
|
|
/**
|
|
* Check if node name is valid
|
|
* @private
|
|
* @param {String} node A name for a node
|
|
* @throws JSJaCJIDInvalidException Thrown if name for node is not allowed
|
|
*/
|
|
JSJaCJID._checkNodeName = function(nodeprep) {
|
|
if (!nodeprep || nodeprep == '')
|
|
return;
|
|
for (var i=0; i< JSJACJID_FORBIDDEN.length; i++) {
|
|
if (nodeprep.indexOf(JSJACJID_FORBIDDEN[i]) != -1) {
|
|
throw new JSJaCJIDInvalidException("forbidden char in nodename: "+JSJACJID_FORBIDDEN[i]);
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Creates a new Exception of type JSJaCJIDInvalidException
|
|
* @class Exception to indicate invalid values for a jid
|
|
* @constructor
|
|
* @param {String} message The message associated with this Exception
|
|
*/
|
|
function JSJaCJIDInvalidException(message) {
|
|
/**
|
|
* The exceptions associated message
|
|
* @type String
|
|
*/
|
|
this.message = message;
|
|
/**
|
|
* The name of the exception
|
|
* @type String
|
|
*/
|
|
this.name = "JSJaCJIDInvalidException";
|
|
}
|
|
|
|
|
|
/* Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person
|
|
* obtaining a copy of this software and associated documentation
|
|
* files (the "Software"), to deal in the Software without
|
|
* restriction, including without limitation the rights to use, copy,
|
|
* modify, merge, publish, distribute, sublicense, and/or sell copies
|
|
* of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be
|
|
* included in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* @private
|
|
* This code is taken from {@link
|
|
* http://wiki.script.aculo.us/scriptaculous/show/Builder
|
|
* script.aculo.us' Dom Builder} and has been modified to suit our
|
|
* needs.<br/>
|
|
* The original parts of the code do have the following
|
|
* copyright and license notice:<br/>
|
|
* Copyright (c) 2005, 2006 Thomas Fuchs (http://script.aculo.us,
|
|
* http://mir.acu lo.us) <br/>
|
|
* script.aculo.us is freely distributable under the terms of an
|
|
* MIT-style license.<br>
|
|
* For details, see the script.aculo.us web site:
|
|
* http://script.aculo.us/<br>
|
|
*/
|
|
var JSJaCBuilder = {
|
|
/**
|
|
* @private
|
|
*/
|
|
buildNode: function(doc, elementName) {
|
|
|
|
var element, ns = arguments[4];
|
|
|
|
// attributes (or text)
|
|
if(arguments[2])
|
|
if(JSJaCBuilder._isStringOrNumber(arguments[2]) ||
|
|
(arguments[2] instanceof Array)) {
|
|
element = this._createElement(doc, elementName, ns);
|
|
JSJaCBuilder._children(doc, element, arguments[2]);
|
|
} else {
|
|
ns = arguments[2]['xmlns'] || ns;
|
|
element = this._createElement(doc, elementName, ns);
|
|
for(attr in arguments[2]) {
|
|
if (arguments[2].hasOwnProperty(attr) && attr != 'xmlns')
|
|
element.setAttribute(attr, arguments[2][attr]);
|
|
}
|
|
}
|
|
else
|
|
element = this._createElement(doc, elementName, ns);
|
|
// text, or array of children
|
|
if(arguments[3])
|
|
JSJaCBuilder._children(doc, element, arguments[3], ns);
|
|
|
|
return element;
|
|
},
|
|
|
|
_createElement: function(doc, elementName, ns) {
|
|
try {
|
|
if (ns)
|
|
return doc.createElementNS(ns, elementName);
|
|
} catch (ex) { }
|
|
|
|
var el = doc.createElement(elementName);
|
|
|
|
if (ns)
|
|
el.setAttribute("xmlns", ns);
|
|
|
|
return el;
|
|
},
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
_text: function(doc, text) {
|
|
return doc.createTextNode(text);
|
|
},
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
_children: function(doc, element, children, ns) {
|
|
if(typeof children=='object') { // array can hold nodes and text
|
|
for (var i in children) {
|
|
if (children.hasOwnProperty(i)) {
|
|
var e = children[i];
|
|
if (typeof e=='object') {
|
|
if (e instanceof Array) {
|
|
var node = JSJaCBuilder.buildNode(doc, e[0], e[1], e[2], ns);
|
|
element.appendChild(node);
|
|
} else {
|
|
element.appendChild(e);
|
|
}
|
|
} else {
|
|
if(JSJaCBuilder._isStringOrNumber(e)) {
|
|
element.appendChild(JSJaCBuilder._text(doc, e));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if(JSJaCBuilder._isStringOrNumber(children)) {
|
|
element.appendChild(JSJaCBuilder._text(doc, children));
|
|
}
|
|
}
|
|
},
|
|
|
|
_attributes: function(attributes) {
|
|
var attrs = [];
|
|
for(attribute in attributes)
|
|
if (attributes.hasOwnProperty(attribute))
|
|
attrs.push(attribute +
|
|
'="' + attributes[attribute].toString().htmlEnc() + '"');
|
|
return attrs.join(" ");
|
|
},
|
|
|
|
_isStringOrNumber: function(param) {
|
|
return(typeof param=='string' || typeof param=='number');
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* @fileoverview Contains all Jabber/XMPP packet related classes.
|
|
* @author Stefan Strigler steve@zeank.in-berlin.de
|
|
* @version $Revision$
|
|
*/
|
|
|
|
var JSJACPACKET_USE_XMLNS = true;
|
|
|
|
/**
|
|
* Creates a new packet with given root tag name (for internal use)
|
|
* @class Somewhat abstract base class for all kinds of specialised packets
|
|
* @param {String} name The root tag name of the packet
|
|
* (i.e. one of 'message', 'iq' or 'presence')
|
|
*/
|
|
function JSJaCPacket(name) {
|
|
/**
|
|
* @private
|
|
*/
|
|
this.name = name;
|
|
|
|
if (typeof(JSJACPACKET_USE_XMLNS) != 'undefined' && JSJACPACKET_USE_XMLNS)
|
|
/**
|
|
* @private
|
|
*/
|
|
this.doc = XmlDocument.create(name,'jabber:client');
|
|
else
|
|
/**
|
|
* @private
|
|
*/
|
|
this.doc = XmlDocument.create(name,'');
|
|
}
|
|
|
|
/**
|
|
* Gets the type (name of root element) of this packet, i.e. one of
|
|
* 'presence', 'message' or 'iq'
|
|
* @return the top level tag name
|
|
* @type String
|
|
*/
|
|
JSJaCPacket.prototype.pType = function() { return this.name; };
|
|
|
|
/**
|
|
* Gets the associated Document for this packet.
|
|
* @type {@link http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#i-Document Document}
|
|
*/
|
|
JSJaCPacket.prototype.getDoc = function() {
|
|
return this.doc;
|
|
};
|
|
/**
|
|
* Gets the root node of this packet
|
|
* @type {@link http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-1950641247 Node}
|
|
*/
|
|
JSJaCPacket.prototype.getNode = function() {
|
|
if (this.getDoc() && this.getDoc().documentElement)
|
|
return this.getDoc().documentElement;
|
|
else
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* Sets the 'to' attribute of the root node of this packet
|
|
* @param {String} to
|
|
* @type JSJaCPacket
|
|
*/
|
|
JSJaCPacket.prototype.setTo = function(to) {
|
|
if (!to || to == '')
|
|
this.getNode().removeAttribute('to');
|
|
else if (typeof(to) == 'string')
|
|
this.getNode().setAttribute('to',to);
|
|
else
|
|
this.getNode().setAttribute('to',to.toString());
|
|
return this;
|
|
};
|
|
/**
|
|
* Sets the 'from' attribute of the root node of this
|
|
* packet. Usually this is not needed as the server will take care
|
|
* of this automatically.
|
|
* @type JSJaCPacket
|
|
*/
|
|
JSJaCPacket.prototype.setFrom = function(from) {
|
|
if (!from || from == '')
|
|
this.getNode().removeAttribute('from');
|
|
else if (typeof(from) == 'string')
|
|
this.getNode().setAttribute('from',from);
|
|
else
|
|
this.getNode().setAttribute('from',from.toString());
|
|
return this;
|
|
};
|
|
/**
|
|
* Sets 'id' attribute of the root node of this packet.
|
|
* @param {String} id The id of the packet.
|
|
* @type JSJaCPacket
|
|
*/
|
|
JSJaCPacket.prototype.setID = function(id) {
|
|
if (!id || id == '')
|
|
this.getNode().removeAttribute('id');
|
|
else
|
|
this.getNode().setAttribute('id',id);
|
|
return this;
|
|
};
|
|
/**
|
|
* Sets the 'type' attribute of the root node of this packet.
|
|
* @param {String} type The type of the packet.
|
|
* @type JSJaCPacket
|
|
*/
|
|
JSJaCPacket.prototype.setType = function(type) {
|
|
if (!type || type == '')
|
|
this.getNode().removeAttribute('type');
|
|
else
|
|
this.getNode().setAttribute('type',type);
|
|
return this;
|
|
};
|
|
/**
|
|
* Sets 'xml:lang' for this packet
|
|
* @param {String} xmllang The xml:lang of the packet.
|
|
* @type JSJaCPacket
|
|
*/
|
|
JSJaCPacket.prototype.setXMLLang = function(xmllang) {
|
|
// Fix IE9+ bug with xml:lang attribute
|
|
if (BrowserDetect && (BrowserDetect.browser == 'Explorer') && (BrowserDetect.version >= 9))
|
|
return this;
|
|
if (!xmllang || xmllang == '')
|
|
this.getNode().removeAttribute('xml:lang');
|
|
else
|
|
this.getNode().setAttribute('xml:lang',xmllang);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Gets the 'to' attribute of this packet
|
|
* @type String
|
|
*/
|
|
JSJaCPacket.prototype.getTo = function() {
|
|
return this.getNode().getAttribute('to');
|
|
};
|
|
/**
|
|
* Gets the 'from' attribute of this packet.
|
|
* @type String
|
|
*/
|
|
JSJaCPacket.prototype.getFrom = function() {
|
|
return this.getNode().getAttribute('from');
|
|
};
|
|
/**
|
|
* Gets the 'to' attribute of this packet as a JSJaCJID object
|
|
* @type JSJaCJID
|
|
*/
|
|
JSJaCPacket.prototype.getToJID = function() {
|
|
return new JSJaCJID(this.getTo());
|
|
};
|
|
/**
|
|
* Gets the 'from' attribute of this packet as a JSJaCJID object
|
|
* @type JSJaCJID
|
|
*/
|
|
JSJaCPacket.prototype.getFromJID = function() {
|
|
return new JSJaCJID(this.getFrom());
|
|
};
|
|
/**
|
|
* Gets the 'id' of this packet
|
|
* @type String
|
|
*/
|
|
JSJaCPacket.prototype.getID = function() {
|
|
return this.getNode().getAttribute('id');
|
|
};
|
|
/**
|
|
* Gets the 'type' of this packet
|
|
* @type String
|
|
*/
|
|
JSJaCPacket.prototype.getType = function() {
|
|
return this.getNode().getAttribute('type');
|
|
};
|
|
/**
|
|
* Gets the 'xml:lang' of this packet
|
|
* @type String
|
|
*/
|
|
JSJaCPacket.prototype.getXMLLang = function() {
|
|
return this.getNode().getAttribute('xml:lang');
|
|
};
|
|
/**
|
|
* Gets the 'xmlns' (xml namespace) of the root node of this packet
|
|
* @type String
|
|
*/
|
|
JSJaCPacket.prototype.getXMLNS = function() {
|
|
return this.getNode().namespaceURI || this.getNode().getAttribute('xmlns');
|
|
};
|
|
|
|
/**
|
|
* Gets a child element of this packet. If no params given returns first child.
|
|
* @param {String} name Tagname of child to retrieve. Use '*' to match any tag. [optional]
|
|
* @param {String} ns Namespace of child. Use '*' to match any ns.[optional]
|
|
* @return The child node, null if none found
|
|
* @type {@link http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-1950641247 Node}
|
|
*/
|
|
JSJaCPacket.prototype.getChild = function(name, ns) {
|
|
if (!this.getNode()) {
|
|
return null;
|
|
}
|
|
|
|
name = name || '*';
|
|
ns = ns || '*';
|
|
|
|
if (this.getNode().getElementsByTagNameNS) {
|
|
return this.getNode().getElementsByTagNameNS(ns, name).item(0);
|
|
}
|
|
|
|
// fallback
|
|
var nodes = this.getNode().getElementsByTagName(name);
|
|
if (ns != '*') {
|
|
for (var i=0; i<nodes.length; i++) {
|
|
if (nodes.item(i).namespaceURI == ns || nodes.item(i).getAttribute('xmlns') == ns) {
|
|
return nodes.item(i);
|
|
}
|
|
}
|
|
} else {
|
|
return nodes.item(0);
|
|
}
|
|
return null; // nothing found
|
|
};
|
|
|
|
/**
|
|
* Gets the node value of a child element of this packet.
|
|
* @param {String} name Tagname of child to retrieve.
|
|
* @param {String} ns Namespace of child
|
|
* @return The value of the child node, empty string if none found
|
|
* @type String
|
|
*/
|
|
JSJaCPacket.prototype.getChildVal = function(name, ns) {
|
|
var node = this.getChild(name, ns);
|
|
var ret = '';
|
|
if (node && node.hasChildNodes()) {
|
|
// concatenate all values from childNodes
|
|
for (var i=0; i<node.childNodes.length; i++)
|
|
if (node.childNodes.item(i).nodeValue)
|
|
ret += node.childNodes.item(i).nodeValue;
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
/**
|
|
* Returns a copy of this node
|
|
* @return a copy of this node
|
|
* @type JSJaCPacket
|
|
*/
|
|
JSJaCPacket.prototype.clone = function() {
|
|
return JSJaCPacket.wrapNode(this.getNode());
|
|
};
|
|
|
|
/**
|
|
* Checks if packet is of type 'error'
|
|
* @return 'true' if this packet is of type 'error', 'false' otherwise
|
|
* @type boolean
|
|
*/
|
|
JSJaCPacket.prototype.isError = function() {
|
|
return (this.getType() == 'error');
|
|
};
|
|
|
|
/**
|
|
* Returns an error condition reply according to {@link http://www.xmpp.org/extensions/xep-0086.html XEP-0086}. Creates a clone of the calling packet with senders and recipient exchanged and error stanza appended.
|
|
* @param {STANZA_ERROR} stanza_error an error stanza containing error cody, type and condition of the error to be indicated
|
|
* @return an error reply packet
|
|
* @type JSJaCPacket
|
|
*/
|
|
JSJaCPacket.prototype.errorReply = function(stanza_error) {
|
|
var rPacket = this.clone();
|
|
rPacket.setTo(this.getFrom());
|
|
rPacket.setFrom();
|
|
rPacket.setType('error');
|
|
|
|
rPacket.appendNode('error',
|
|
{code: stanza_error.code, type: stanza_error.type},
|
|
[[stanza_error.cond]]);
|
|
|
|
return rPacket;
|
|
};
|
|
|
|
/**
|
|
* Returns a string representation of the raw xml content of this packet.
|
|
* @type String
|
|
*/
|
|
JSJaCPacket.prototype.xml = typeof XMLSerializer != 'undefined' ?
|
|
function() {
|
|
var r = (new XMLSerializer()).serializeToString(this.getNode());
|
|
if (typeof(r) == 'undefined')
|
|
r = (new XMLSerializer()).serializeToString(this.doc); // oldschool
|
|
return r
|
|
} :
|
|
function() {// IE
|
|
return this.getDoc().xml
|
|
};
|
|
|
|
|
|
// PRIVATE METHODS DOWN HERE
|
|
|
|
/**
|
|
* Gets an attribute of the root element
|
|
* @private
|
|
*/
|
|
JSJaCPacket.prototype._getAttribute = function(attr) {
|
|
return this.getNode().getAttribute(attr);
|
|
};
|
|
|
|
|
|
if (document.ELEMENT_NODE == null) {
|
|
document.ELEMENT_NODE = 1;
|
|
document.ATTRIBUTE_NODE = 2;
|
|
document.TEXT_NODE = 3;
|
|
document.CDATA_SECTION_NODE = 4;
|
|
document.ENTITY_REFERENCE_NODE = 5;
|
|
document.ENTITY_NODE = 6;
|
|
document.PROCESSING_INSTRUCTION_NODE = 7;
|
|
document.COMMENT_NODE = 8;
|
|
document.DOCUMENT_NODE = 9;
|
|
document.DOCUMENT_TYPE_NODE = 10;
|
|
document.DOCUMENT_FRAGMENT_NODE = 11;
|
|
document.NOTATION_NODE = 12;
|
|
}
|
|
|
|
/**
|
|
* import node into this packets document
|
|
* @private
|
|
*/
|
|
JSJaCPacket.prototype._importNode = function(node, allChildren) {
|
|
switch (node.nodeType) {
|
|
case document.ELEMENT_NODE:
|
|
|
|
if (this.getDoc().createElementNS) {
|
|
var newNode = this.getDoc().createElementNS(node.namespaceURI, node.nodeName);
|
|
} else {
|
|
var newNode = this.getDoc().createElement(node.nodeName);
|
|
}
|
|
|
|
/* does the node have any attributes to add? */
|
|
if (node.attributes && node.attributes.length > 0)
|
|
for (var i = 0, il = node.attributes.length;i < il; i++) {
|
|
var attr = node.attributes.item(i);
|
|
if (attr.nodeName == 'xmlns' && newNode.getAttribute('xmlns') != null ) continue;
|
|
if (newNode.setAttributeNS && attr.namespaceURI) {
|
|
newNode.setAttributeNS(attr.namespaceURI,
|
|
attr.nodeName,
|
|
attr.nodeValue);
|
|
} else {
|
|
newNode.setAttribute(attr.nodeName,
|
|
attr.nodeValue);
|
|
}
|
|
}
|
|
/* are we going after children too, and does the node have any? */
|
|
if (allChildren && node.childNodes && node.childNodes.length > 0) {
|
|
for (var i = 0, il = node.childNodes.length; i < il; i++) {
|
|
newNode.appendChild(this._importNode(node.childNodes.item(i), allChildren));
|
|
}
|
|
}
|
|
return newNode;
|
|
break;
|
|
case document.TEXT_NODE:
|
|
case document.CDATA_SECTION_NODE:
|
|
case document.COMMENT_NODE:
|
|
return this.getDoc().createTextNode(node.nodeValue);
|
|
break;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Set node value of a child node
|
|
* @private
|
|
*/
|
|
JSJaCPacket.prototype._setChildNode = function(nodeName, nodeValue) {
|
|
var aNode = this.getChild(nodeName);
|
|
var tNode = this.getDoc().createTextNode(nodeValue);
|
|
if (aNode)
|
|
try {
|
|
aNode.replaceChild(tNode,aNode.firstChild);
|
|
} catch (e) { }
|
|
else {
|
|
try {
|
|
aNode = this.getDoc().createElementNS(this.getNode().namespaceURI,
|
|
nodeName);
|
|
} catch (ex) {
|
|
aNode = this.getDoc().createElement(nodeName)
|
|
}
|
|
this.getNode().appendChild(aNode);
|
|
aNode.appendChild(tNode);
|
|
}
|
|
return aNode;
|
|
};
|
|
|
|
/**
|
|
* Builds a node using {@link
|
|
* http://wiki.script.aculo.us/scriptaculous/show/Builder
|
|
* script.aculo.us' Dom Builder} notation.
|
|
* This code is taken from {@link
|
|
* http://wiki.script.aculo.us/scriptaculous/show/Builder
|
|
* script.aculo.us' Dom Builder} and has been modified to suit our
|
|
* needs.<br/>
|
|
* The original parts of the code do have the following copyright
|
|
* and license notice:<br/>
|
|
* Copyright (c) 2005, 2006 Thomas Fuchs (http://script.aculo.us,
|
|
* http://mir.acu lo.us) <br/>
|
|
* script.aculo.us is freely distributable under the terms of an
|
|
* MIT-style licen se. // For details, see the script.aculo.us web
|
|
* site: http://script.aculo.us/<br>
|
|
* @author Thomas Fuchs
|
|
* @author Stefan Strigler
|
|
* @return The newly created node
|
|
* @type {@link http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-1950641247 Node}
|
|
*/
|
|
JSJaCPacket.prototype.buildNode = function(elementName) {
|
|
return JSJaCBuilder.buildNode(this.getDoc(),
|
|
elementName,
|
|
arguments[1],
|
|
arguments[2]);
|
|
};
|
|
|
|
/**
|
|
* Appends node created by buildNode to this packets parent node.
|
|
* @param {@link http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-1950641247 Node} element The node to append or
|
|
* @param {String} element A name plus an object hash with attributes (optional) plus an array of childnodes (optional)
|
|
* @see #buildNode
|
|
* @return This packet
|
|
* @type JSJaCPacket
|
|
*/
|
|
JSJaCPacket.prototype.appendNode = function(element) {
|
|
if (typeof element=='object') { // seems to be a prebuilt node
|
|
return this.getNode().appendChild(element)
|
|
} else { // build node
|
|
return this.getNode().appendChild(this.buildNode(element,
|
|
arguments[1],
|
|
arguments[2],
|
|
null,
|
|
this.getNode().namespaceURI));
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* A jabber/XMPP presence packet
|
|
* @class Models the XMPP notion of a 'presence' packet
|
|
* @extends JSJaCPacket
|
|
*/
|
|
function JSJaCPresence() {
|
|
/**
|
|
* @ignore
|
|
*/
|
|
this.base = JSJaCPacket;
|
|
this.base('presence');
|
|
}
|
|
JSJaCPresence.prototype = new JSJaCPacket;
|
|
|
|
/**
|
|
* Sets the status message for current status. Usually this is set
|
|
* to some human readable string indicating what the user is
|
|
* doing/feel like currently.
|
|
* @param {String} status A status message
|
|
* @return this
|
|
* @type JSJaCPacket
|
|
*/
|
|
JSJaCPresence.prototype.setStatus = function(status) {
|
|
this._setChildNode("status", status);
|
|
return this;
|
|
};
|
|
/**
|
|
* Sets the online status for this presence packet.
|
|
* @param {String} show An XMPP complient status indicator. Must
|
|
* be one of 'chat', 'away', 'xa', 'dnd'
|
|
* @return this
|
|
* @type JSJaCPacket
|
|
*/
|
|
JSJaCPresence.prototype.setShow = function(show) {
|
|
if (show == 'chat' || show == 'away' || show == 'xa' || show == 'dnd')
|
|
this._setChildNode("show",show);
|
|
return this;
|
|
};
|
|
/**
|
|
* Sets the priority of the resource bind to with this connection
|
|
* @param {int} prio The priority to set this resource to
|
|
* @return this
|
|
* @type JSJaCPacket
|
|
*/
|
|
JSJaCPresence.prototype.setPriority = function(prio) {
|
|
this._setChildNode("priority", prio);
|
|
return this;
|
|
};
|
|
/**
|
|
* Some combined method that allowes for setting show, status and
|
|
* priority at once
|
|
* @param {String} show A status message
|
|
* @param {String} status A status indicator as defined by XMPP
|
|
* @param {int} prio A priority for this resource
|
|
* @return this
|
|
* @type JSJaCPacket
|
|
*/
|
|
JSJaCPresence.prototype.setPresence = function(show,status,prio) {
|
|
if (show)
|
|
this.setShow(show);
|
|
if (status)
|
|
this.setStatus(status);
|
|
if (prio)
|
|
this.setPriority(prio);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Gets the status message of this presence
|
|
* @return The (human readable) status message
|
|
* @type String
|
|
*/
|
|
JSJaCPresence.prototype.getStatus = function() {
|
|
return this.getChildVal('status');
|
|
};
|
|
/**
|
|
* Gets the status of this presence.
|
|
* Either one of 'chat', 'away', 'xa' or 'dnd' or null.
|
|
* @return The status indicator as defined by XMPP
|
|
* @type String
|
|
*/
|
|
JSJaCPresence.prototype.getShow = function() {
|
|
return this.getChildVal('show');
|
|
};
|
|
/**
|
|
* Gets the priority of this status message
|
|
* @return A resource priority
|
|
* @type int
|
|
*/
|
|
JSJaCPresence.prototype.getPriority = function() {
|
|
return this.getChildVal('priority');
|
|
};
|
|
|
|
|
|
/**
|
|
* A jabber/XMPP iq packet
|
|
* @class Models the XMPP notion of an 'iq' packet
|
|
* @extends JSJaCPacket
|
|
*/
|
|
function JSJaCIQ() {
|
|
/**
|
|
* @ignore
|
|
*/
|
|
this.base = JSJaCPacket;
|
|
this.base('iq');
|
|
}
|
|
JSJaCIQ.prototype = new JSJaCPacket;
|
|
|
|
/**
|
|
* Some combined method to set 'to', 'type' and 'id' at once
|
|
* @param {String} to the recepients JID
|
|
* @param {String} type A XMPP compliant iq type (one of 'set', 'get', 'result' and 'error'
|
|
* @param {String} id A packet ID
|
|
* @return this
|
|
* @type JSJaCIQ
|
|
*/
|
|
JSJaCIQ.prototype.setIQ = function(to,type,id) {
|
|
if (to)
|
|
this.setTo(to);
|
|
if (type)
|
|
this.setType(type);
|
|
if (id)
|
|
this.setID(id);
|
|
return this;
|
|
};
|
|
/**
|
|
* Creates a 'query' child node with given XMLNS
|
|
* @param {String} xmlns The namespace for the 'query' node
|
|
* @return The query node
|
|
* @type {@link http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-1950641247 Node}
|
|
*/
|
|
JSJaCIQ.prototype.setQuery = function(xmlns) {
|
|
var query;
|
|
try {
|
|
query = this.getDoc().createElementNS(xmlns,'query');
|
|
} catch (e) {
|
|
query = this.getDoc().createElement('query');
|
|
query.setAttribute('xmlns',xmlns);
|
|
}
|
|
this.getNode().appendChild(query);
|
|
return query;
|
|
};
|
|
|
|
/**
|
|
* Gets the 'query' node of this packet
|
|
* @return The query node
|
|
* @type {@link http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-1950641247 Node}
|
|
*/
|
|
JSJaCIQ.prototype.getQuery = function() {
|
|
return this.getNode().getElementsByTagName('query').item(0);
|
|
};
|
|
/**
|
|
* Gets the XMLNS of the query node contained within this packet
|
|
* @return The namespace of the query node
|
|
* @type String
|
|
*/
|
|
JSJaCIQ.prototype.getQueryXMLNS = function() {
|
|
if (this.getQuery()) {
|
|
return this.getQuery().namespaceURI || this.getQuery().getAttribute('xmlns');
|
|
} else {
|
|
return null;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Creates an IQ reply with type set to 'result'. If given appends payload to first child if IQ. Payload maybe XML as string or a DOM element (or an array of such elements as well).
|
|
* @param {Element} payload A payload to be appended [optional]
|
|
* @return An IQ reply packet
|
|
* @type JSJaCIQ
|
|
*/
|
|
JSJaCIQ.prototype.reply = function(payload) {
|
|
var rIQ = this.clone();
|
|
rIQ.setTo(this.getFrom());
|
|
rIQ.setFrom();
|
|
rIQ.setType('result');
|
|
if (payload) {
|
|
if (typeof payload == 'string')
|
|
rIQ.getChild().appendChild(rIQ.getDoc().loadXML(payload));
|
|
else if (payload.constructor == Array) {
|
|
var node = rIQ.getChild();
|
|
for (var i=0; i<payload.length; i++)
|
|
if(typeof payload[i] == 'string')
|
|
node.appendChild(rIQ.getDoc().loadXML(payload[i]));
|
|
else if (typeof payload[i] == 'object')
|
|
node.appendChild(payload[i]);
|
|
}
|
|
else if (typeof payload == 'object')
|
|
rIQ.getChild().appendChild(payload);
|
|
}
|
|
return rIQ;
|
|
};
|
|
|
|
/**
|
|
* A jabber/XMPP message packet
|
|
* @class Models the XMPP notion of an 'message' packet
|
|
* @extends JSJaCPacket
|
|
*/
|
|
function JSJaCMessage() {
|
|
/**
|
|
* @ignore
|
|
*/
|
|
this.base = JSJaCPacket;
|
|
this.base('message');
|
|
}
|
|
JSJaCMessage.prototype = new JSJaCPacket;
|
|
|
|
/**
|
|
* Sets the body of the message
|
|
* @param {String} body Your message to be sent along
|
|
* @return this message
|
|
* @type JSJaCMessage
|
|
*/
|
|
JSJaCMessage.prototype.setBody = function(body) {
|
|
this._setChildNode("body",body);
|
|
return this;
|
|
};
|
|
/**
|
|
* Sets the subject of the message
|
|
* @param {String} subject Your subject to be sent along
|
|
* @return this message
|
|
* @type JSJaCMessage
|
|
*/
|
|
JSJaCMessage.prototype.setSubject = function(subject) {
|
|
this._setChildNode("subject",subject);
|
|
return this;
|
|
};
|
|
/**
|
|
* Sets the 'tread' attribute for this message. This is used to identify
|
|
* threads in chat conversations
|
|
* @param {String} thread Usually a somewhat random hash.
|
|
* @return this message
|
|
* @type JSJaCMessage
|
|
*/
|
|
JSJaCMessage.prototype.setThread = function(thread) {
|
|
this._setChildNode("thread", thread);
|
|
return this;
|
|
};
|
|
/**
|
|
* Gets the 'thread' identifier for this message
|
|
* @return A thread identifier
|
|
* @type String
|
|
*/
|
|
JSJaCMessage.prototype.getThread = function() {
|
|
return this.getChildVal('thread');
|
|
};
|
|
/**
|
|
* Gets the body of this message
|
|
* @return The body of this message
|
|
* @type String
|
|
*/
|
|
JSJaCMessage.prototype.getBody = function() {
|
|
return this.getChildVal('body');
|
|
};
|
|
/**
|
|
* Gets the subject of this message
|
|
* @return The subject of this message
|
|
* @type String
|
|
*/
|
|
JSJaCMessage.prototype.getSubject = function() {
|
|
return this.getChildVal('subject')
|
|
};
|
|
|
|
|
|
/**
|
|
* Tries to transform a w3c DOM node to JSJaC's internal representation
|
|
* (JSJaCPacket type, one of JSJaCPresence, JSJaCMessage, JSJaCIQ)
|
|
* @param: {Node
|
|
* http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-1950641247}
|
|
* node The node to be transformed
|
|
* @return A JSJaCPacket representing the given node. If node's root
|
|
* elemenent is not one of 'message', 'presence' or 'iq',
|
|
* <code>null</code> is being returned.
|
|
* @type JSJaCPacket
|
|
*/
|
|
JSJaCPacket.wrapNode = function(node) {
|
|
var oPacket = null;
|
|
|
|
switch (node.nodeName.toLowerCase()) {
|
|
case 'presence':
|
|
oPacket = new JSJaCPresence();
|
|
break;
|
|
case 'message':
|
|
oPacket = new JSJaCMessage();
|
|
break;
|
|
case 'iq':
|
|
oPacket = new JSJaCIQ();
|
|
break;
|
|
}
|
|
|
|
if (oPacket) {
|
|
oPacket.getDoc().replaceChild(oPacket._importNode(node, true),
|
|
oPacket.getNode());
|
|
}
|
|
|
|
return oPacket;
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
* an error packet for internal use
|
|
* @private
|
|
* @constructor
|
|
*/
|
|
function JSJaCError(code,type,condition) {
|
|
var xmldoc = XmlDocument.create("error","jsjac");
|
|
|
|
xmldoc.documentElement.setAttribute('code',code);
|
|
xmldoc.documentElement.setAttribute('type',type);
|
|
if (condition)
|
|
xmldoc.documentElement.appendChild(xmldoc.createElement(condition)).
|
|
setAttribute('xmlns','urn:ietf:params:xml:ns:xmpp-stanzas');
|
|
return xmldoc.documentElement;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Creates a new set of hash keys
|
|
* @class Reflects a set of sha1/md5 hash keys for securing sessions
|
|
* @constructor
|
|
* @param {Function} func The hash function to be used for creating the keys
|
|
* @param {Debugger} oDbg Reference to debugger implementation [optional]
|
|
*/
|
|
function JSJaCKeys(func,oDbg) {
|
|
var seed = Math.random();
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
this._k = new Array();
|
|
this._k[0] = seed.toString();
|
|
if (oDbg)
|
|
/**
|
|
* Reference to Debugger
|
|
* @type Debugger
|
|
*/
|
|
this.oDbg = oDbg;
|
|
else {
|
|
this.oDbg = {};
|
|
this.oDbg.log = function() {};
|
|
}
|
|
|
|
if (func) {
|
|
for (var i=1; i<JSJAC_NKEYS; i++) {
|
|
this._k[i] = func(this._k[i-1]);
|
|
oDbg.log(i+": "+this._k[i],4);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
this._indexAt = JSJAC_NKEYS-1;
|
|
/**
|
|
* Gets next key from stack
|
|
* @return New hash key
|
|
* @type String
|
|
*/
|
|
this.getKey = function() {
|
|
return this._k[this._indexAt--];
|
|
};
|
|
/**
|
|
* Indicates whether there's only one key left
|
|
* @return <code>true</code> if there's only one key left, false otherwise
|
|
* @type boolean
|
|
*/
|
|
this.lastKey = function() { return (this._indexAt == 0); };
|
|
/**
|
|
* Returns number of overall/initial stack size
|
|
* @return Number of keys created
|
|
* @type int
|
|
*/
|
|
this.size = function() { return this._k.length; };
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
this._getSuspendVars = function() {
|
|
return ('_k,_indexAt').split(',');
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* @fileoverview Contains all things in common for all subtypes of connections
|
|
* supported.
|
|
* @author Stefan Strigler steve@zeank.in-berlin.de
|
|
* @version $Revision$
|
|
*/
|
|
|
|
/**
|
|
* Creates a new Jabber connection (a connection to a jabber server)
|
|
* @class Somewhat abstract base class for jabber connections. Contains all
|
|
* of the code in common for all jabber connections
|
|
* @constructor
|
|
* @param {JSON http://www.json.org/index} oArg JSON with properties: <br>
|
|
* * <code>httpbase</code> the http base address of the service to be used for
|
|
* connecting to jabber<br>
|
|
* * <code>oDbg</code> (optional) a reference to a debugger interface
|
|
*/
|
|
function JSJaCConnection(oArg) {
|
|
|
|
if (oArg && oArg.oDbg && oArg.oDbg.log) {
|
|
/**
|
|
* Reference to debugger interface
|
|
* (needs to implement method <code>log</code>)
|
|
* @type Debugger
|
|
*/
|
|
this.oDbg = oArg.oDbg;
|
|
} else {
|
|
this.oDbg = new Object(); // always initialise a debugger
|
|
this.oDbg.log = function() { };
|
|
}
|
|
|
|
if (oArg && oArg.timerval)
|
|
this.setPollInterval(oArg.timerval);
|
|
else
|
|
this.setPollInterval(JSJAC_TIMERVAL);
|
|
|
|
if (oArg && oArg.httpbase)
|
|
/**
|
|
* @private
|
|
*/
|
|
this._httpbase = oArg.httpbase;
|
|
|
|
if (oArg &&oArg.allow_plain)
|
|
/**
|
|
* @private
|
|
*/
|
|
this.allow_plain = oArg.allow_plain;
|
|
else
|
|
this.allow_plain = JSJAC_ALLOW_PLAIN;
|
|
|
|
if (oArg && oArg.cookie_prefix)
|
|
/**
|
|
* @private
|
|
*/
|
|
this._cookie_prefix = oArg.cookie_prefix;
|
|
else
|
|
this._cookie_prefix = "";
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
this._connected = false;
|
|
/**
|
|
* @private
|
|
*/
|
|
this._events = new Array();
|
|
/**
|
|
* @private
|
|
*/
|
|
this._keys = null;
|
|
/**
|
|
* @private
|
|
*/
|
|
this._ID = 0;
|
|
/**
|
|
* @private
|
|
*/
|
|
this._inQ = new Array();
|
|
/**
|
|
* @private
|
|
*/
|
|
this._pQueue = new Array();
|
|
/**
|
|
* @private
|
|
*/
|
|
this._regIDs = new Array();
|
|
/**
|
|
* @private
|
|
*/
|
|
this._req = new Array();
|
|
/**
|
|
* @private
|
|
*/
|
|
this._status = 'intialized';
|
|
/**
|
|
* @private
|
|
*/
|
|
this._errcnt = 0;
|
|
/**
|
|
* @private
|
|
*/
|
|
this._inactivity = JSJAC_INACTIVITY;
|
|
/**
|
|
* @private
|
|
*/
|
|
this._sendRawCallbacks = new Array();
|
|
}
|
|
|
|
// Generates an ID
|
|
var STANZA_ID = 1;
|
|
|
|
function genID() {
|
|
return STANZA_ID++;
|
|
}
|
|
|
|
JSJaCConnection.prototype.connect = function(oArg) {
|
|
this._setStatus('connecting');
|
|
|
|
this.domain = oArg.domain || 'localhost';
|
|
this.username = oArg.username;
|
|
this.resource = oArg.resource;
|
|
this.pass = oArg.pass;
|
|
this.register = oArg.register;
|
|
|
|
this.authhost = oArg.authhost || this.domain;
|
|
this.authtype = oArg.authtype || 'sasl';
|
|
|
|
if (oArg.xmllang && oArg.xmllang != '')
|
|
this._xmllang = oArg.xmllang;
|
|
else
|
|
this._xmllang = 'en';
|
|
|
|
this.host = oArg.host || this.domain;
|
|
this.port = oArg.port || 5222;
|
|
if (oArg.secure)
|
|
this.secure = 'true';
|
|
else
|
|
this.secure = 'false';
|
|
|
|
if (oArg.wait)
|
|
this._wait = oArg.wait;
|
|
|
|
this.jid = this.username + '@' + this.domain;
|
|
this.fulljid = this.jid + '/' + this.resource;
|
|
|
|
this._rid = Math.round( 100000.5 + ( ( (900000.49999) - (100000.5) ) * Math.random() ) );
|
|
|
|
// setupRequest must be done after rid is created but before first use in reqstr
|
|
var slot = this._getFreeSlot();
|
|
this._req[slot] = this._setupRequest(true);
|
|
|
|
var reqstr = this._getInitialRequestString();
|
|
|
|
this.oDbg.log(reqstr,4);
|
|
|
|
this._req[slot].r.onreadystatechange =
|
|
JSJaC.bind(function() {
|
|
var r = this._req[slot].r;
|
|
if (r.readyState == 4) {
|
|
this.oDbg.log("async recv: "+r.responseText,4);
|
|
this._handleInitialResponse(r); // handle response
|
|
}
|
|
}, this);
|
|
|
|
if (typeof(this._req[slot].r.onerror) != 'undefined') {
|
|
this._req[slot].r.onerror =
|
|
JSJaC.bind(function(e) {
|
|
this.oDbg.log('XmlHttpRequest error',1);
|
|
return false;
|
|
}, this);
|
|
}
|
|
|
|
this._req[slot].r.send(reqstr);
|
|
};
|
|
|
|
/**
|
|
* Tells whether this connection is connected
|
|
* @return <code>true</code> if this connections is connected,
|
|
* <code>false</code> otherwise
|
|
* @type boolean
|
|
*/
|
|
JSJaCConnection.prototype.connected = function() { return this._connected; };
|
|
|
|
/**
|
|
* Disconnects from jabber server and terminates session (if applicable)
|
|
*/
|
|
JSJaCConnection.prototype.disconnect = function() {
|
|
this._setStatus('disconnecting');
|
|
|
|
if (!this.connected())
|
|
return;
|
|
this._connected = false;
|
|
|
|
clearInterval(this._interval);
|
|
clearInterval(this._inQto);
|
|
|
|
if (this._timeout)
|
|
clearTimeout(this._timeout); // remove timer
|
|
|
|
var slot = this._getFreeSlot();
|
|
// Intentionally synchronous
|
|
this._req[slot] = this._setupRequest(false);
|
|
|
|
request = this._getRequestString(false, true);
|
|
|
|
this.oDbg.log("Disconnecting: " + request,4);
|
|
this._req[slot].r.send(request);
|
|
|
|
try {
|
|
removeDB('jsjac', 'state');
|
|
} catch (e) {}
|
|
|
|
this.oDbg.log("Disconnected: "+this._req[slot].r.responseText,2);
|
|
this._handleEvent('ondisconnect');
|
|
};
|
|
|
|
/**
|
|
* Gets current value of polling interval
|
|
* @return Polling interval in milliseconds
|
|
* @type int
|
|
*/
|
|
JSJaCConnection.prototype.getPollInterval = function() {
|
|
return this._timerval;
|
|
};
|
|
|
|
/**
|
|
* Registers an event handler (callback) for this connection.
|
|
|
|
* <p>Note: All of the packet handlers for specific packets (like
|
|
* message_in, presence_in and iq_in) fire only if there's no
|
|
* callback associated with the id.<br>
|
|
|
|
* <p>Example:<br/>
|
|
* <code>con.registerHandler('iq', 'query', 'jabber:iq:version', handleIqVersion);</code>
|
|
|
|
|
|
* @param {String} event One of
|
|
|
|
* <ul>
|
|
* <li>onConnect - connection has been established and authenticated</li>
|
|
* <li>onDisconnect - connection has been disconnected</li>
|
|
* <li>onResume - connection has been resumed</li>
|
|
|
|
* <li>onStatusChanged - connection status has changed, current
|
|
* status as being passed argument to handler. See {@link #status}.</li>
|
|
|
|
* <li>onError - an error has occured, error node is supplied as
|
|
* argument, like this:<br><code><error code='404' type='cancel'><br>
|
|
* <item-not-found xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/><br>
|
|
* </error></code></li>
|
|
|
|
* <li>packet_in - a packet has been received (argument: the
|
|
* packet)</li>
|
|
|
|
* <li>packet_out - a packet is to be sent(argument: the
|
|
* packet)</li>
|
|
|
|
* <li>message_in | message - a message has been received (argument:
|
|
* the packet)</li>
|
|
|
|
* <li>message_out - a message packet is to be sent (argument: the
|
|
* packet)</li>
|
|
|
|
* <li>presence_in | presence - a presence has been received
|
|
* (argument: the packet)</li>
|
|
|
|
* <li>presence_out - a presence packet is to be sent (argument: the
|
|
* packet)</li>
|
|
|
|
* <li>iq_in | iq - an iq has been received (argument: the packet)</li>
|
|
* <li>iq_out - an iq is to be sent (argument: the packet)</li>
|
|
* </ul>
|
|
|
|
* @param {String} childName A childnode's name that must occur within a
|
|
* retrieved packet [optional]
|
|
|
|
* @param {String} childNS A childnode's namespace that must occure within
|
|
* a retrieved packet (works only if childName is given) [optional]
|
|
|
|
* @param {String} type The type of the packet to handle (works only if childName and chidNS are given (both may be set to '*' in order to get skipped) [optional]
|
|
|
|
* @param {Function} handler The handler to be called when event occurs. If your handler returns 'true' it cancels bubbling of the event. No other registered handlers for this event will be fired.
|
|
*/
|
|
JSJaCConnection.prototype.registerHandler = function(event) {
|
|
event = event.toLowerCase(); // don't be case-sensitive here
|
|
var eArg = {handler: arguments[arguments.length-1],
|
|
childName: '*',
|
|
childNS: '*',
|
|
type: '*'};
|
|
if (arguments.length > 2)
|
|
eArg.childName = arguments[1];
|
|
if (arguments.length > 3)
|
|
eArg.childNS = arguments[2];
|
|
if (arguments.length > 4)
|
|
eArg.type = arguments[3];
|
|
if (!this._events[event])
|
|
this._events[event] = new Array(eArg);
|
|
else
|
|
this._events[event] = this._events[event].concat(eArg);
|
|
|
|
// sort events in order how specific they match criterias thus using
|
|
// wildcard patterns puts them back in queue when it comes to
|
|
// bubbling the event
|
|
this._events[event] =
|
|
this._events[event].sort(function(a,b) {
|
|
var aRank = 0;
|
|
var bRank = 0;
|
|
with (a) {
|
|
if (type == '*')
|
|
aRank++;
|
|
if (childNS == '*')
|
|
aRank++;
|
|
if (childName == '*')
|
|
aRank++;
|
|
}
|
|
with (b) {
|
|
if (type == '*')
|
|
bRank++;
|
|
if (childNS == '*')
|
|
bRank++;
|
|
if (childName == '*')
|
|
bRank++;
|
|
}
|
|
if (aRank > bRank)
|
|
return 1;
|
|
if (aRank < bRank)
|
|
return -1;
|
|
return 0;
|
|
});
|
|
this.oDbg.log("registered handler for event '"+event+"'",2);
|
|
};
|
|
|
|
JSJaCConnection.prototype.unregisterHandler = function(event,handler) {
|
|
event = event.toLowerCase(); // don't be case-sensitive here
|
|
|
|
if (!this._events[event])
|
|
return;
|
|
|
|
var arr = this._events[event], res = new Array();
|
|
for (var i=0; i<arr.length; i++)
|
|
if (arr[i].handler != handler)
|
|
res.push(arr[i]);
|
|
|
|
if (arr.length != res.length) {
|
|
this._events[event] = res;
|
|
this.oDbg.log("unregistered handler for event '"+event+"'",2);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Register for iq packets of type 'get'.
|
|
* @param {String} childName A childnode's name that must occur within a
|
|
* retrieved packet
|
|
|
|
* @param {String} childNS A childnode's namespace that must occure within
|
|
* a retrieved packet (works only if childName is given)
|
|
|
|
* @param {Function} handler The handler to be called when event occurs. If your handler returns 'true' it cancels bubbling of the event. No other registered handlers for this event will be fired.
|
|
*/
|
|
JSJaCConnection.prototype.registerIQGet = function(childName, childNS, handler) {
|
|
this.registerHandler('iq', childName, childNS, 'get', handler);
|
|
};
|
|
|
|
/**
|
|
* Register for iq packets of type 'set'.
|
|
* @param {String} childName A childnode's name that must occur within a
|
|
* retrieved packet
|
|
|
|
* @param {String} childNS A childnode's namespace that must occure within
|
|
* a retrieved packet (works only if childName is given)
|
|
|
|
* @param {Function} handler The handler to be called when event occurs. If your handler returns 'true' it cancels bubbling of the event. No other registered handlers for this event will be fired.
|
|
*/
|
|
JSJaCConnection.prototype.registerIQSet = function(childName, childNS, handler) {
|
|
this.registerHandler('iq', childName, childNS, 'set', handler);
|
|
};
|
|
|
|
/**
|
|
* Resumes this connection from saved state (cookie)
|
|
* @return Whether resume was successful
|
|
* @type boolean
|
|
*/
|
|
JSJaCConnection.prototype.resume = function() {
|
|
try {
|
|
var json = getDB('jsjac', 'state');
|
|
this.oDbg.log('read cookie: '+json,2);
|
|
removeDB('jsjac', 'state');
|
|
|
|
return this.resumeFromData(JSJaCJSON.parse(json));
|
|
} catch (e) {}
|
|
return false; // sth went wrong
|
|
};
|
|
|
|
/**
|
|
* Resumes BOSH connection from data
|
|
* @param {Object} serialized jsjac state information
|
|
* @return Whether resume was successful
|
|
* @type boolean
|
|
*/
|
|
JSJaCConnection.prototype.resumeFromData = function(data) {
|
|
try {
|
|
this._setStatus('resuming');
|
|
|
|
for (var i in data)
|
|
if (data.hasOwnProperty(i))
|
|
this[i] = data[i];
|
|
|
|
// copy keys - not being very generic here :-/
|
|
if (this._keys) {
|
|
this._keys2 = new JSJaCKeys();
|
|
var u = this._keys2._getSuspendVars();
|
|
for (var i=0; i<u.length; i++)
|
|
this._keys2[u[i]] = this._keys[u[i]];
|
|
this._keys = this._keys2;
|
|
}
|
|
|
|
if (this._connected) {
|
|
// don't poll too fast!
|
|
this._handleEvent('onresume');
|
|
setTimeout(JSJaC.bind(this._resume, this),this.getPollInterval());
|
|
this._interval = setInterval(JSJaC.bind(this._checkQueue, this),
|
|
JSJAC_CHECKQUEUEINTERVAL);
|
|
this._inQto = setInterval(JSJaC.bind(this._checkInQ, this),
|
|
JSJAC_CHECKINQUEUEINTERVAL);
|
|
}
|
|
|
|
return (this._connected === true);
|
|
} catch (e) {
|
|
if (e.message)
|
|
this.oDbg.log("Resume failed: "+e.message, 1);
|
|
else
|
|
this.oDbg.log("Resume failed: "+e, 1);
|
|
return false;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Sends a JSJaCPacket
|
|
* @param {JSJaCPacket} packet The packet to send
|
|
* @param {Function} cb The callback to be called if there's a reply
|
|
* to this packet (identified by id) [optional]
|
|
* @param {Object} arg Arguments passed to the callback
|
|
* (additionally to the packet received) [optional]
|
|
* @return 'true' if sending was successfull, 'false' otherwise
|
|
* @type boolean
|
|
*/
|
|
JSJaCConnection.prototype.send = function(packet,cb,arg) {
|
|
if (!packet || !packet.pType) {
|
|
this.oDbg.log("no packet: "+packet, 1);
|
|
return false;
|
|
}
|
|
|
|
if (!this.connected())
|
|
return false;
|
|
|
|
// generate an ID for the packet
|
|
if (!packet.getID())
|
|
packet.setID(genID());
|
|
|
|
// packet xml:lang
|
|
if (!packet.getXMLLang())
|
|
packet.setXMLLang(XML_LANG);
|
|
|
|
// remember id for response if callback present
|
|
if (cb)
|
|
this._registerPID(packet.getID(),cb,arg);
|
|
|
|
try {
|
|
this._handleEvent(packet.pType()+'_out', packet);
|
|
this._handleEvent("packet_out", packet);
|
|
this._pQueue = this._pQueue.concat(packet.xml());
|
|
} catch (e) {
|
|
this.oDbg.log(e.toString(),1);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
/**
|
|
* Sends an IQ packet. Has default handlers for each reply type.
|
|
* Those maybe overriden by passing an appropriate handler.
|
|
* @param {JSJaCIQPacket} iq - the iq packet to send
|
|
* @param {Object} handlers - object with properties 'error_handler',
|
|
* 'result_handler' and 'default_handler'
|
|
* with appropriate functions
|
|
* @param {Object} arg - argument to handlers
|
|
* @return 'true' if sending was successfull, 'false' otherwise
|
|
* @type boolean
|
|
*/
|
|
JSJaCConnection.prototype.sendIQ = function(iq, handlers, arg) {
|
|
if (!iq || iq.pType() != 'iq') {
|
|
return false;
|
|
}
|
|
|
|
handlers = handlers || {};
|
|
var error_handler = handlers.error_handler || JSJaC.bind(function(aIq) {
|
|
this.oDbg.log(aIq.xml(), 1);
|
|
}, this);
|
|
|
|
var result_handler = handlers.result_handler || JSJaC.bind(function(aIq) {
|
|
this.oDbg.log(aIq.xml(), 2);
|
|
}, this);
|
|
|
|
var iqHandler = function(aIq, arg) {
|
|
switch (aIq.getType()) {
|
|
case 'error':
|
|
error_handler(aIq);
|
|
break;
|
|
case 'result':
|
|
result_handler(aIq, arg);
|
|
break;
|
|
}
|
|
};
|
|
return this.send(iq, iqHandler, arg);
|
|
};
|
|
|
|
/**
|
|
* Sets polling interval for this connection
|
|
* @param {int} millisecs Milliseconds to set timer to
|
|
* @return effective interval this connection has been set to
|
|
* @type int
|
|
*/
|
|
JSJaCConnection.prototype.setPollInterval = function(timerval) {
|
|
if (timerval && !isNaN(timerval))
|
|
this._timerval = timerval;
|
|
return this._timerval;
|
|
};
|
|
|
|
/**
|
|
* Returns current status of this connection
|
|
* @return String to denote current state. One of
|
|
* <ul>
|
|
* <li>'initializing' ... well
|
|
* <li>'connecting' if connect() was called
|
|
* <li>'resuming' if resume() was called
|
|
* <li>'processing' if it's about to operate as normal
|
|
* <li>'onerror_fallback' if there was an error with the request object
|
|
* <li>'protoerror_fallback' if there was an error at the http binding protocol flow (most likely that's where you interested in)
|
|
* <li>'internal_server_error' in case of an internal server error
|
|
* <li>'suspending' if suspend() is being called
|
|
* <li>'aborted' if abort() was called
|
|
* <li>'disconnecting' if disconnect() has been called
|
|
* </ul>
|
|
* @type String
|
|
*/
|
|
JSJaCConnection.prototype.status = function() { return this._status; };
|
|
|
|
/**
|
|
* Suspends this connection (saving state for later resume)
|
|
* Saves state to cookie
|
|
* @return Whether suspend (saving to cookie) was successful
|
|
* @type boolean
|
|
*/
|
|
JSJaCConnection.prototype.suspend = function(has_pause) {
|
|
var data = this.suspendToData(has_pause);
|
|
|
|
try {
|
|
var c = setDB('jsjac', 'state', JSJaCJSON.toString(data));
|
|
return c;
|
|
} catch (e) {
|
|
this.oDbg.log("Failed creating cookie '"+this._cookie_prefix+
|
|
"JSJaC_State': "+e.message,1);
|
|
}
|
|
return false;
|
|
};
|
|
|
|
/**
|
|
* Suspend connection and return serialized JSJaC connection state
|
|
* @return JSJaC connection state object
|
|
* @type Object
|
|
*/
|
|
JSJaCConnection.prototype.suspendToData = function(has_pause) {
|
|
|
|
// remove timers
|
|
if(has_pause) {
|
|
clearTimeout(this._timeout);
|
|
clearInterval(this._interval);
|
|
clearInterval(this._inQto);
|
|
|
|
this._suspend();
|
|
}
|
|
|
|
var u = ('_connected,_keys,_ID,_inQ,_pQueue,_regIDs,_errcnt,_inactivity,domain,username,resource,jid,fulljid,_sid,_httpbase,_timerval,_is_polling').split(',');
|
|
u = u.concat(this._getSuspendVars());
|
|
var s = new Object();
|
|
|
|
for (var i=0; i<u.length; i++) {
|
|
if (!this[u[i]]) continue; // hu? skip these!
|
|
if (this[u[i]]._getSuspendVars) {
|
|
var uo = this[u[i]]._getSuspendVars();
|
|
var o = new Object();
|
|
for (var j=0; j<uo.length; j++)
|
|
o[uo[j]] = this[u[i]][uo[j]];
|
|
} else
|
|
var o = this[u[i]];
|
|
|
|
s[u[i]] = o;
|
|
}
|
|
|
|
if(has_pause) {
|
|
this._connected = false;
|
|
this._setStatus('suspending');
|
|
}
|
|
|
|
return s;
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCConnection.prototype._abort = function() {
|
|
clearTimeout(this._timeout); // remove timer
|
|
|
|
clearInterval(this._inQto);
|
|
clearInterval(this._interval);
|
|
|
|
this._connected = false;
|
|
|
|
this._setStatus('aborted');
|
|
|
|
this.oDbg.log("Disconnected.",1);
|
|
this._handleEvent('ondisconnect');
|
|
this._handleEvent('onerror',
|
|
JSJaCError('500','cancel','service-unavailable'));
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCConnection.prototype._checkInQ = function() {
|
|
for (var i=0; i<this._inQ.length && i<10; i++) {
|
|
var item = this._inQ[0];
|
|
this._inQ = this._inQ.slice(1,this._inQ.length);
|
|
var packet = JSJaCPacket.wrapNode(item);
|
|
|
|
if (!packet)
|
|
return;
|
|
|
|
this._handleEvent("packet_in", packet);
|
|
|
|
if (packet.pType && !this._handlePID(packet)) {
|
|
this._handleEvent(packet.pType()+'_in',packet);
|
|
this._handleEvent(packet.pType(),packet);
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCConnection.prototype._checkQueue = function() {
|
|
if (this._pQueue.length != 0)
|
|
this._process();
|
|
return true;
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCConnection.prototype._doAuth = function() {
|
|
if (this.has_sasl && this.authtype == 'nonsasl')
|
|
this.oDbg.log("Warning: SASL present but not used", 1);
|
|
|
|
if (!this._doSASLAuth() &&
|
|
!this._doLegacyAuth()) {
|
|
this.oDbg.log("Auth failed for authtype "+this.authtype,1);
|
|
this.disconnect();
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCConnection.prototype._doInBandReg = function() {
|
|
if (this.authtype == 'saslanon' || this.authtype == 'anonymous')
|
|
return; // bullshit - no need to register if anonymous
|
|
|
|
/* ***
|
|
* In-Band Registration see JEP-0077
|
|
*/
|
|
|
|
var iq = new JSJaCIQ();
|
|
iq.setType('set');
|
|
iq.setID('reg1');
|
|
iq.appendNode("query", {xmlns: "jabber:iq:register"},
|
|
[["username", this.username],
|
|
["password", this.pass]]);
|
|
|
|
this.send(iq,this._doInBandRegDone);
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCConnection.prototype._doInBandRegDone = function(iq) {
|
|
if (iq && iq.getType() == 'error') { // we failed to register
|
|
this.oDbg.log("registration failed for "+this.username,0);
|
|
this._handleEvent('onerror',iq.getChild('error'));
|
|
return;
|
|
}
|
|
|
|
this.oDbg.log(this.username + " registered succesfully",0);
|
|
|
|
this._doAuth();
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCConnection.prototype._doLegacyAuth = function() {
|
|
if (this.authtype != 'nonsasl' && this.authtype != 'anonymous')
|
|
return false;
|
|
|
|
/* ***
|
|
* Non-SASL Authentication as described in JEP-0078
|
|
*/
|
|
var iq = new JSJaCIQ();
|
|
iq.setIQ(null,'get','auth1');
|
|
iq.appendNode('query', {xmlns: 'jabber:iq:auth'},
|
|
[['username', this.username]]);
|
|
|
|
this.send(iq,this._doLegacyAuth2);
|
|
return true;
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCConnection.prototype._doLegacyAuth2 = function(iq) {
|
|
if (!iq || iq.getType() != 'result') {
|
|
if (iq && iq.getType() == 'error')
|
|
this._handleEvent('onerror',iq.getChild('error'));
|
|
this.disconnect();
|
|
return;
|
|
}
|
|
|
|
var use_digest = (iq.getChild('digest') != null);
|
|
|
|
/* ***
|
|
* Send authentication
|
|
*/
|
|
var iq = new JSJaCIQ();
|
|
iq.setIQ(null,'set','auth2');
|
|
|
|
query = iq.appendNode('query', {xmlns: 'jabber:iq:auth'},
|
|
[['username', this.username],
|
|
['resource', this.resource]]);
|
|
|
|
if (use_digest) { // digest login
|
|
query.appendChild(iq.buildNode('digest', {xmlns: 'jabber:iq:auth'},
|
|
hex_sha1(this.streamid + this.pass)));
|
|
} else if (this.allow_plain) { // use plaintext auth
|
|
query.appendChild(iq.buildNode('password', {xmlns: 'jabber:iq:auth'},
|
|
this.pass));
|
|
} else {
|
|
this.oDbg.log("no valid login mechanism found",1);
|
|
this.disconnect();
|
|
return false;
|
|
}
|
|
|
|
this.send(iq,this._doLegacyAuthDone);
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCConnection.prototype._doLegacyAuthDone = function(iq) {
|
|
if (iq.getType() != 'result') { // auth' failed
|
|
if (iq.getType() == 'error')
|
|
this._handleEvent('onerror',iq.getChild('error'));
|
|
this.disconnect();
|
|
} else
|
|
this._handleEvent('onconnect');
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCConnection.prototype._doSASLAuth = function() {
|
|
if (this.authtype == 'nonsasl' || this.authtype == 'anonymous')
|
|
return false;
|
|
|
|
if (this.authtype == 'saslanon') {
|
|
if (this.mechs['ANONYMOUS']) {
|
|
this.oDbg.log("SASL using mechanism 'ANONYMOUS'",2);
|
|
return this._sendRaw("<auth xmlns='urn:ietf:params:xml:ns:xmpp-sasl' mechanism='ANONYMOUS'/>",
|
|
this._doSASLAuthDone);
|
|
}
|
|
this.oDbg.log("SASL ANONYMOUS requested but not supported",1);
|
|
} else {
|
|
if (this.mechs['DIGEST-MD5']) {
|
|
this.oDbg.log("SASL using mechanism 'DIGEST-MD5'",2);
|
|
return this._sendRaw("<auth xmlns='urn:ietf:params:xml:ns:xmpp-sasl' mechanism='DIGEST-MD5'/>",
|
|
this._doSASLAuthDigestMd5S1);
|
|
} else if (this.allow_plain && this.mechs['PLAIN']) {
|
|
this.oDbg.log("SASL using mechanism 'PLAIN'",2);
|
|
var authStr = this.username+'@'+
|
|
this.domain+String.fromCharCode(0)+
|
|
this.username+String.fromCharCode(0)+
|
|
this.pass;
|
|
this.oDbg.log("authenticating with '"+authStr+"'",2);
|
|
authStr = b64encode(authStr);
|
|
return this._sendRaw("<auth xmlns='urn:ietf:params:xml:ns:xmpp-sasl' mechanism='PLAIN'>"+authStr+"</auth>",
|
|
this._doSASLAuthDone);
|
|
}
|
|
this.oDbg.log("No SASL mechanism applied",1);
|
|
this.authtype = 'nonsasl'; // fallback
|
|
}
|
|
return false;
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCConnection.prototype._doSASLAuthDigestMd5S1 = function(el) {
|
|
if (el.nodeName != "challenge") {
|
|
this.oDbg.log("challenge missing",1);
|
|
this._handleEvent('onerror',JSJaCError('401','auth','not-authorized'));
|
|
this.disconnect();
|
|
} else {
|
|
var challenge = b64decode(el.firstChild.nodeValue);
|
|
this.oDbg.log("got challenge: "+challenge,2);
|
|
this._nonce = challenge.substring(challenge.indexOf("nonce=")+7);
|
|
this._nonce = this._nonce.substring(0,this._nonce.indexOf("\""));
|
|
this.oDbg.log("nonce: "+this._nonce,2);
|
|
if (this._nonce == '' || this._nonce.indexOf('\"') != -1) {
|
|
this.oDbg.log("nonce not valid, aborting",1);
|
|
this.disconnect();
|
|
return;
|
|
}
|
|
|
|
this._digest_uri = "xmpp/";
|
|
// if (typeof(this.host) != 'undefined' && this.host != '') {
|
|
// this._digest-uri += this.host;
|
|
// if (typeof(this.port) != 'undefined' && this.port)
|
|
// this._digest-uri += ":" + this.port;
|
|
// this._digest-uri += '/';
|
|
// }
|
|
this._digest_uri += this.domain;
|
|
|
|
this._cnonce = cnonce(14);
|
|
|
|
this._nc = '00000001';
|
|
|
|
var A1 = str_md5(this.username+':'+this.domain+':'+this.pass)+
|
|
':'+this._nonce+':'+this._cnonce;
|
|
|
|
var A2 = 'AUTHENTICATE:'+this._digest_uri;
|
|
|
|
var response = hex_md5(hex_md5(A1)+':'+this._nonce+':'+this._nc+':'+
|
|
this._cnonce+':auth:'+hex_md5(A2));
|
|
|
|
var rPlain = 'username="'+this.username+'",realm="'+this.domain+
|
|
'",nonce="'+this._nonce+'",cnonce="'+this._cnonce+'",nc="'+this._nc+
|
|
'",qop=auth,digest-uri="'+this._digest_uri+'",response="'+response+
|
|
'",charset="utf-8"';
|
|
|
|
this.oDbg.log("response: "+rPlain,2);
|
|
|
|
this._sendRaw("<response xmlns='urn:ietf:params:xml:ns:xmpp-sasl'>"+
|
|
b64encode(rPlain)+"</response>",
|
|
this._doSASLAuthDigestMd5S2);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCConnection.prototype._doSASLAuthDigestMd5S2 = function(el) {
|
|
if (el.nodeName == 'failure') {
|
|
if (el.xml)
|
|
this.oDbg.log("auth error: "+el.xml,1);
|
|
else
|
|
this.oDbg.log("auth error",1);
|
|
this._handleEvent('onerror',JSJaCError('401','auth','not-authorized'));
|
|
this.disconnect();
|
|
return;
|
|
}
|
|
|
|
var response = b64decode(el.firstChild.nodeValue);
|
|
this.oDbg.log("response: "+response,2);
|
|
|
|
var rspauth = response.substring(response.indexOf("rspauth=")+8);
|
|
this.oDbg.log("rspauth: "+rspauth,2);
|
|
|
|
var A1 = str_md5(this.username+':'+this.domain+':'+this.pass)+
|
|
':'+this._nonce+':'+this._cnonce;
|
|
|
|
var A2 = ':'+this._digest_uri;
|
|
|
|
var rsptest = hex_md5(hex_md5(A1)+':'+this._nonce+':'+this._nc+':'+
|
|
this._cnonce+':auth:'+hex_md5(A2));
|
|
this.oDbg.log("rsptest: "+rsptest,2);
|
|
|
|
if (rsptest != rspauth) {
|
|
this.oDbg.log("SASL Digest-MD5: server repsonse with wrong rspauth",1);
|
|
this.disconnect();
|
|
return;
|
|
}
|
|
|
|
if (el.nodeName == 'success') {
|
|
this._reInitStream(JSJaC.bind(this._doStreamBind, this));
|
|
} else { // some extra turn
|
|
this._sendRaw("<response xmlns='urn:ietf:params:xml:ns:xmpp-sasl'/>",
|
|
this._doSASLAuthDone);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCConnection.prototype._doSASLAuthDone = function (el) {
|
|
if (el.nodeName != 'success') {
|
|
this.oDbg.log("auth failed",1);
|
|
this._handleEvent('onerror',JSJaCError('401','auth','not-authorized'));
|
|
this.disconnect();
|
|
} else {
|
|
this._reInitStream(JSJaC.bind(this._doStreamBind, this));
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCConnection.prototype._doStreamBind = function() {
|
|
var iq = new JSJaCIQ();
|
|
iq.setIQ(null,'set','bind_1');
|
|
iq.appendNode("bind", {xmlns: "urn:ietf:params:xml:ns:xmpp-bind"},
|
|
[["resource", this.resource]]);
|
|
this.oDbg.log(iq.xml());
|
|
this.send(iq,this._doXMPPSess);
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCConnection.prototype._doXMPPSess = function(iq) {
|
|
if (iq.getType() != 'result' || iq.getType() == 'error') { // failed
|
|
this.disconnect();
|
|
if (iq.getType() == 'error')
|
|
this._handleEvent('onerror',iq.getChild('error'));
|
|
return;
|
|
}
|
|
|
|
this.fulljid = iq.getChildVal("jid");
|
|
this.jid = this.fulljid.substring(0,this.fulljid.lastIndexOf('/'));
|
|
|
|
iq = new JSJaCIQ();
|
|
iq.setIQ(null,'set','sess_1');
|
|
iq.appendNode("session", {xmlns: "urn:ietf:params:xml:ns:xmpp-session"},
|
|
[]);
|
|
this.oDbg.log(iq.xml());
|
|
this.send(iq,this._doXMPPSessDone);
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCConnection.prototype._doXMPPSessDone = function(iq) {
|
|
if (iq.getType() != 'result' || iq.getType() == 'error') { // failed
|
|
this.disconnect();
|
|
if (iq.getType() == 'error')
|
|
this._handleEvent('onerror',iq.getChild('error'));
|
|
return;
|
|
} else
|
|
this._handleEvent('onconnect');
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCConnection.prototype._handleEvent = function(event,arg) {
|
|
event = event.toLowerCase(); // don't be case-sensitive here
|
|
this.oDbg.log("incoming event '"+event+"'",3);
|
|
if (!this._events[event])
|
|
return;
|
|
this.oDbg.log("handling event '"+event+"'",2);
|
|
for (var i=0;i<this._events[event].length; i++) {
|
|
var aEvent = this._events[event][i];
|
|
if (typeof aEvent.handler == 'function') {
|
|
try {
|
|
if (arg) {
|
|
if (arg.pType) { // it's a packet
|
|
if ((!arg.getNode().hasChildNodes() && aEvent.childName != '*') ||
|
|
(arg.getNode().hasChildNodes() &&
|
|
!arg.getChild(aEvent.childName, aEvent.childNS)))
|
|
continue;
|
|
if (aEvent.type != '*' &&
|
|
arg.getType() != aEvent.type)
|
|
continue;
|
|
this.oDbg.log(aEvent.childName+"/"+aEvent.childNS+"/"+aEvent.type+" => match for handler "+aEvent.handler,3);
|
|
}
|
|
if (aEvent.handler(arg)) {
|
|
// handled!
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
if (aEvent.handler()) {
|
|
// handled!
|
|
break;
|
|
}
|
|
} catch (e) {
|
|
|
|
if (e.fileName&&e.lineNumber) {
|
|
this.oDbg.log(aEvent.handler+"\n>>>"+e.name+": "+ e.message+' in '+e.fileName+' line '+e.lineNumber,1);
|
|
} else {
|
|
this.oDbg.log(aEvent.handler+"\n>>>"+e.name+": "+ e.message,1);
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCConnection.prototype._handlePID = function(aJSJaCPacket) {
|
|
if (!aJSJaCPacket.getID())
|
|
return false;
|
|
for (var i in this._regIDs) {
|
|
if (this._regIDs.hasOwnProperty(i) &&
|
|
this._regIDs[i] && i == aJSJaCPacket.getID()) {
|
|
var pID = aJSJaCPacket.getID();
|
|
this.oDbg.log("handling "+pID,3);
|
|
try {
|
|
if (this._regIDs[i].cb.call(this, aJSJaCPacket, this._regIDs[i].arg) === false) {
|
|
// don't unregister
|
|
return false;
|
|
} else {
|
|
this._unregisterPID(pID);
|
|
return true;
|
|
}
|
|
} catch (e) {
|
|
// broken handler?
|
|
this.oDbg.log(e.name+": "+ e.message, 1);
|
|
this._unregisterPID(pID);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCConnection.prototype._handleResponse = function(req) {
|
|
var rootEl = this._parseResponse(req);
|
|
|
|
if (!rootEl)
|
|
return;
|
|
|
|
for (var i=0; i<rootEl.childNodes.length; i++) {
|
|
if (this._sendRawCallbacks.length) {
|
|
var cb = this._sendRawCallbacks[0];
|
|
this._sendRawCallbacks = this._sendRawCallbacks.slice(1, this._sendRawCallbacks.length);
|
|
cb.fn.call(this, rootEl.childNodes.item(i), cb.arg);
|
|
continue;
|
|
}
|
|
this._inQ = this._inQ.concat(rootEl.childNodes.item(i));
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCConnection.prototype._parseStreamFeatures = function(doc) {
|
|
if (!doc) {
|
|
this.oDbg.log("nothing to parse ... aborting",1);
|
|
return false;
|
|
}
|
|
|
|
var errorTag;
|
|
if (doc.getElementsByTagNameNS) {
|
|
errorTag = doc.getElementsByTagNameNS("http://etherx.jabber.org/streams", "error").item(0);
|
|
} else {
|
|
var errors = doc.getElementsByTagName("error");
|
|
for (var i=0; i<errors.length; i++)
|
|
if (errors.item(i).namespaceURI == "http://etherx.jabber.org/streams" ||
|
|
errors.item(i).getAttribute('xmlns') == "http://etherx.jabber.org/streams") {
|
|
errorTag = errors.item(i);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (errorTag) {
|
|
this._setStatus("internal_server_error");
|
|
clearTimeout(this._timeout); // remove timer
|
|
clearInterval(this._interval);
|
|
clearInterval(this._inQto);
|
|
this._handleEvent('onerror',JSJaCError('503','cancel','session-terminate'));
|
|
this._connected = false;
|
|
this.oDbg.log("Disconnected.",1);
|
|
this._handleEvent('ondisconnect');
|
|
return false;
|
|
}
|
|
|
|
this.mechs = new Object();
|
|
var lMec1 = doc.getElementsByTagName("mechanisms");
|
|
this.has_sasl = false;
|
|
for (var i=0; i<lMec1.length; i++)
|
|
if (lMec1.item(i).getAttribute("xmlns") ==
|
|
"urn:ietf:params:xml:ns:xmpp-sasl") {
|
|
this.has_sasl=true;
|
|
var lMec2 = lMec1.item(i).getElementsByTagName("mechanism");
|
|
for (var j=0; j<lMec2.length; j++)
|
|
this.mechs[lMec2.item(j).firstChild.nodeValue] = true;
|
|
break;
|
|
}
|
|
if (this.has_sasl)
|
|
this.oDbg.log("SASL detected",2);
|
|
else {
|
|
this.oDbg.log("No support for SASL detected",2);
|
|
return false;
|
|
}
|
|
|
|
// Get the server CAPS (if available)
|
|
this.server_caps=null;
|
|
var sCaps = doc.getElementsByTagName("c");
|
|
for (var i=0; i<sCaps.length; i++) {
|
|
var c_sCaps=sCaps.item(i);
|
|
var x_sCaps=c_sCaps.getAttribute("xmlns");
|
|
var v_sCaps=c_sCaps.getAttribute("ver");
|
|
|
|
if ((x_sCaps == NS_CAPS) && v_sCaps) {
|
|
this.server_caps=v_sCaps;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCConnection.prototype._process = function(timerval) {
|
|
if (!this.connected()) {
|
|
this.oDbg.log("Connection lost ...",1);
|
|
if (this._interval)
|
|
clearInterval(this._interval);
|
|
return;
|
|
}
|
|
|
|
this.setPollInterval(timerval);
|
|
|
|
if (this._timeout)
|
|
clearTimeout(this._timeout);
|
|
|
|
var slot = this._getFreeSlot();
|
|
|
|
if (slot < 0)
|
|
return;
|
|
|
|
if (typeof(this._req[slot]) != 'undefined' &&
|
|
typeof(this._req[slot].r) != 'undefined' &&
|
|
this._req[slot].r.readyState != 4) {
|
|
this.oDbg.log("Slot "+slot+" is not ready");
|
|
return;
|
|
}
|
|
|
|
if (!this.isPolling() && this._pQueue.length == 0 &&
|
|
this._req[(slot+1)%2] && this._req[(slot+1)%2].r.readyState != 4) {
|
|
this.oDbg.log("all slots busy, standby ...", 2);
|
|
return;
|
|
}
|
|
|
|
if (!this.isPolling())
|
|
this.oDbg.log("Found working slot at "+slot,2);
|
|
|
|
this._req[slot] = this._setupRequest(true);
|
|
|
|
/* setup onload handler for async send */
|
|
this._req[slot].r.onreadystatechange =
|
|
JSJaC.bind(function() {
|
|
if (this._req[slot].r.readyState == 4) {
|
|
this._setStatus('processing');
|
|
this.oDbg.log("async recv: "+this._req[slot].r.responseText,4);
|
|
this._handleResponse(this._req[slot]);
|
|
|
|
if (!this.connected())
|
|
return;
|
|
|
|
// schedule next tick
|
|
if (this._pQueue.length) {
|
|
this._timeout = setTimeout(JSJaC.bind(this._process, this),100);
|
|
} else {
|
|
this.oDbg.log("scheduling next poll in "+this.getPollInterval()+
|
|
" msec", 4);
|
|
this._timeout = setTimeout(JSJaC.bind(this._process, this),this.getPollInterval());
|
|
}
|
|
}
|
|
}, this);
|
|
|
|
try {
|
|
this._req[slot].r.onerror =
|
|
JSJaC.bind(function() {
|
|
if (!this.connected())
|
|
return;
|
|
this._errcnt++;
|
|
this.oDbg.log('XmlHttpRequest error ('+this._errcnt+')',1);
|
|
if (this._errcnt > JSJAC_ERR_COUNT) {
|
|
// abort
|
|
this._abort();
|
|
return false;
|
|
}
|
|
|
|
this._setStatus('onerror_fallback');
|
|
|
|
// schedule next tick
|
|
setTimeout(JSJaC.bind(this._resume, this),this.getPollInterval());
|
|
return false;
|
|
}, this);
|
|
} catch(e) { } // well ... no onerror property available, maybe we
|
|
// can catch the error somewhere else ...
|
|
|
|
var reqstr = this._getRequestString();
|
|
|
|
if (typeof(this._rid) != 'undefined') // remember request id if any
|
|
this._req[slot].rid = this._rid;
|
|
|
|
this.oDbg.log("sending: " + reqstr,4);
|
|
this._req[slot].r.send(reqstr);
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCConnection.prototype._registerPID = function(pID,cb,arg) {
|
|
if (!pID || !cb)
|
|
return false;
|
|
this._regIDs[pID] = new Object();
|
|
this._regIDs[pID].cb = cb;
|
|
if (arg)
|
|
this._regIDs[pID].arg = arg;
|
|
this.oDbg.log("registered "+pID,3);
|
|
return true;
|
|
};
|
|
|
|
/**
|
|
* partial function binding sendEmpty to callback
|
|
* @private
|
|
*/
|
|
JSJaCConnection.prototype._prepSendEmpty = function(cb, ctx) {
|
|
return function() {
|
|
ctx._sendEmpty(JSJaC.bind(cb, ctx));
|
|
};
|
|
};
|
|
|
|
/**
|
|
* send empty request
|
|
* waiting for stream id to be able to proceed with authentication
|
|
* @private
|
|
*/
|
|
JSJaCConnection.prototype._sendEmpty = function(cb) {
|
|
var slot = this._getFreeSlot();
|
|
this._req[slot] = this._setupRequest(true);
|
|
|
|
this._req[slot].r.onreadystatechange =
|
|
JSJaC.bind(function() {
|
|
if (this._req[slot].r.readyState == 4) {
|
|
this.oDbg.log("async recv: "+this._req[slot].r.responseText,4);
|
|
cb(this._req[slot].r); // handle response
|
|
}
|
|
},this);
|
|
|
|
if (typeof(this._req[slot].r.onerror) != 'undefined') {
|
|
this._req[slot].r.onerror =
|
|
JSJaC.bind(function(e) {
|
|
this.oDbg.log('XmlHttpRequest error',1);
|
|
return false;
|
|
}, this);
|
|
}
|
|
|
|
var reqstr = this._getRequestString();
|
|
this.oDbg.log("sending: " + reqstr,4);
|
|
this._req[slot].r.send(reqstr);
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCConnection.prototype._sendRaw = function(xml,cb,arg) {
|
|
if (cb)
|
|
this._sendRawCallbacks.push({fn: cb, arg: arg});
|
|
|
|
this._pQueue.push(xml);
|
|
this._process();
|
|
|
|
return true;
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCConnection.prototype._setStatus = function(status) {
|
|
if (!status || status == '')
|
|
return;
|
|
if (status != this._status) { // status changed!
|
|
this._status = status;
|
|
this._handleEvent('onstatuschanged', status);
|
|
this._handleEvent('status_changed', status);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCConnection.prototype._unregisterPID = function(pID) {
|
|
if (!this._regIDs[pID])
|
|
return false;
|
|
this._regIDs[pID] = null;
|
|
this.oDbg.log("unregistered "+pID,3);
|
|
return true;
|
|
};
|
|
|
|
|
|
/**
|
|
* @fileoverview All stuff related to HTTP Binding
|
|
* @author Stefan Strigler steve@zeank.in-berlin.de
|
|
* @version $Revision$
|
|
*/
|
|
|
|
/**
|
|
* Instantiates an HTTP Binding session
|
|
* @class Implementation of {@link
|
|
* http://www.xmpp.org/extensions/xep-0206.html XMPP Over BOSH}
|
|
* formerly known as HTTP Binding.
|
|
* @extends JSJaCConnection
|
|
* @constructor
|
|
*/
|
|
function JSJaCHttpBindingConnection(oArg) {
|
|
/**
|
|
* @ignore
|
|
*/
|
|
this.base = JSJaCConnection;
|
|
this.base(oArg);
|
|
|
|
// member vars
|
|
/**
|
|
* @private
|
|
*/
|
|
this._hold = JSJACHBC_MAX_HOLD;
|
|
/**
|
|
* @private
|
|
*/
|
|
this._inactivity = 0;
|
|
/**
|
|
* @private
|
|
*/
|
|
this._last_requests = new Object(); // 'hash' storing hold+1 last requests
|
|
/**
|
|
* @private
|
|
*/
|
|
this._last_rid = 0; // I know what you did last summer
|
|
/**
|
|
* @private
|
|
*/
|
|
this._min_polling = 0;
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
this._pause = 0;
|
|
/**
|
|
* @private
|
|
*/
|
|
this._wait = JSJACHBC_MAX_WAIT;
|
|
}
|
|
JSJaCHttpBindingConnection.prototype = new JSJaCConnection();
|
|
|
|
/**
|
|
* Inherit an instantiated HTTP Binding session
|
|
*/
|
|
JSJaCHttpBindingConnection.prototype.inherit = function(oArg) {
|
|
if (oArg.jid) {
|
|
var oJid = new JSJaCJID(oArg.jid);
|
|
this.domain = oJid.getDomain();
|
|
this.username = oJid.getNode();
|
|
this.resource = oJid.getResource();
|
|
} else {
|
|
this.domain = oArg.domain || 'localhost';
|
|
this.username = oArg.username;
|
|
this.resource = oArg.resource;
|
|
}
|
|
this._sid = oArg.sid;
|
|
this._rid = oArg.rid;
|
|
this._min_polling = oArg.polling;
|
|
this._inactivity = oArg.inactivity;
|
|
this._setHold(oArg.requests-1);
|
|
this.setPollInterval(this._timerval);
|
|
if (oArg.wait)
|
|
this._wait = oArg.wait; // for whatever reason
|
|
|
|
this._connected = true;
|
|
|
|
this._handleEvent('onconnect');
|
|
|
|
this._interval= setInterval(JSJaC.bind(this._checkQueue, this),
|
|
JSJAC_CHECKQUEUEINTERVAL);
|
|
this._inQto = setInterval(JSJaC.bind(this._checkInQ, this),
|
|
JSJAC_CHECKINQUEUEINTERVAL);
|
|
this._timeout = setTimeout(JSJaC.bind(this._process, this),
|
|
this.getPollInterval());
|
|
};
|
|
|
|
/**
|
|
* Sets poll interval
|
|
* @param {int} timerval the interval in seconds
|
|
*/
|
|
JSJaCHttpBindingConnection.prototype.setPollInterval = function(timerval) {
|
|
if (timerval && !isNaN(timerval)) {
|
|
if (!this.isPolling())
|
|
this._timerval = 100;
|
|
else if (this._min_polling && timerval < this._min_polling*1000)
|
|
this._timerval = this._min_polling*1000;
|
|
else if (this._inactivity && timerval > this._inactivity*1000)
|
|
this._timerval = this._inactivity*1000;
|
|
else
|
|
this._timerval = timerval;
|
|
}
|
|
return this._timerval;
|
|
};
|
|
|
|
/**
|
|
* whether this session is in polling mode
|
|
* @type boolean
|
|
*/
|
|
JSJaCHttpBindingConnection.prototype.isPolling = function() { return (this._hold == 0) };
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCHttpBindingConnection.prototype._getFreeSlot = function() {
|
|
for (var i=0; i<this._hold+1; i++)
|
|
if (typeof(this._req[i]) == 'undefined' || typeof(this._req[i].r) == 'undefined' || this._req[i].r.readyState == 4)
|
|
return i;
|
|
return -1; // nothing found
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCHttpBindingConnection.prototype._getHold = function() { return this._hold; };
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCHttpBindingConnection.prototype._getRequestString = function(raw, last) {
|
|
raw = raw || '';
|
|
var reqstr = '';
|
|
|
|
// check if we're repeating a request
|
|
|
|
if (this._rid <= this._last_rid && typeof(this._last_requests[this._rid]) != 'undefined') // repeat!
|
|
reqstr = this._last_requests[this._rid].xml;
|
|
else { // grab from queue
|
|
var xml = '';
|
|
while (this._pQueue.length) {
|
|
var curNode = this._pQueue[0];
|
|
xml += curNode;
|
|
this._pQueue = this._pQueue.slice(1,this._pQueue.length);
|
|
}
|
|
|
|
reqstr = "<body xml:lang='"+XML_LANG+"' rid='"+this._rid+"' sid='"+this._sid+"' xmlns='http://jabber.org/protocol/httpbind' ";
|
|
if (JSJAC_HAVEKEYS) {
|
|
reqstr += "key='"+this._keys.getKey()+"' ";
|
|
if (this._keys.lastKey()) {
|
|
this._keys = new JSJaCKeys(hex_sha1,this.oDbg);
|
|
reqstr += "newkey='"+this._keys.getKey()+"' ";
|
|
}
|
|
}
|
|
if (last)
|
|
reqstr += "type='terminate'";
|
|
else if (this._reinit) {
|
|
if (JSJACHBC_USE_BOSH_VER)
|
|
reqstr += "xmpp:restart='true' xmlns:xmpp='urn:xmpp:xbosh' to='"+this.domain+"'";
|
|
this._reinit = false;
|
|
}
|
|
|
|
if (xml != '' || raw != '') {
|
|
reqstr += ">" + raw + xml + "</body>";
|
|
} else {
|
|
reqstr += "/>";
|
|
}
|
|
|
|
this._last_requests[this._rid] = new Object();
|
|
this._last_requests[this._rid].xml = reqstr;
|
|
this._last_rid = this._rid;
|
|
|
|
for (var i in this._last_requests)
|
|
if (this._last_requests.hasOwnProperty(i) &&
|
|
i < this._rid-this._hold)
|
|
delete(this._last_requests[i]); // truncate
|
|
}
|
|
|
|
return reqstr;
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCHttpBindingConnection.prototype._getInitialRequestString = function() {
|
|
var reqstr = "<body xml:lang='"+XML_LANG+"' content='text/xml; charset=utf-8' hold='"+this._hold+"' xmlns='http://jabber.org/protocol/httpbind' to='"+this.authhost+"' wait='"+this._wait+"' rid='"+this._rid+"'";
|
|
if (this.secure)
|
|
reqstr += " secure='"+this.secure+"'";
|
|
if (JSJAC_HAVEKEYS) {
|
|
this._keys = new JSJaCKeys(hex_sha1,this.oDbg); // generate first set of keys
|
|
key = this._keys.getKey();
|
|
reqstr += " newkey='"+key+"'";
|
|
}
|
|
|
|
if (JSJACHBC_USE_BOSH_VER) {
|
|
reqstr += " ver='" + JSJACHBC_BOSH_VERSION + "'";
|
|
reqstr += " xmlns:xmpp='urn:xmpp:xbosh'";
|
|
if (this.authtype == 'sasl' || this.authtype == 'saslanon')
|
|
reqstr += " xmpp:version='1.0'";
|
|
}
|
|
reqstr += "/>";
|
|
return reqstr;
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCHttpBindingConnection.prototype._getStreamID = function(req) {
|
|
|
|
this.oDbg.log(req.responseText,4);
|
|
|
|
if (!req.responseXML || !req.responseXML.documentElement) {
|
|
this._handleEvent('onerror',JSJaCError('503','cancel','service-unavailable'));
|
|
return;
|
|
}
|
|
var body = req.responseXML.documentElement;
|
|
|
|
// any session error?
|
|
if(body.getAttribute('type') == 'terminate') {
|
|
this._handleEvent('onerror',JSJaCError('503','cancel','service-unavailable'));
|
|
return;
|
|
}
|
|
|
|
// extract stream id used for non-SASL authentication
|
|
if (body.getAttribute('authid')) {
|
|
this.streamid = body.getAttribute('authid');
|
|
this.oDbg.log("got streamid: "+this.streamid,2);
|
|
}
|
|
|
|
if (!this._parseStreamFeatures(body)) {
|
|
this._sendEmpty(JSJaC.bind(this._getStreamID, this));
|
|
return;
|
|
}
|
|
|
|
this._timeout = setTimeout(JSJaC.bind(this._process, this),
|
|
this.getPollInterval());
|
|
|
|
if (this.register)
|
|
this._doInBandReg();
|
|
else
|
|
this._doAuth();
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCHttpBindingConnection.prototype._getSuspendVars = function() {
|
|
return ('host,port,secure,_rid,_last_rid,_wait,_min_polling,_inactivity,_hold,_last_requests,_pause').split(',');
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCHttpBindingConnection.prototype._handleInitialResponse = function(req) {
|
|
try {
|
|
// This will throw an error on Mozilla when the connection was refused
|
|
this.oDbg.log(req.getAllResponseHeaders(),4);
|
|
this.oDbg.log(req.responseText,4);
|
|
} catch(ex) {
|
|
this.oDbg.log("No response",4);
|
|
}
|
|
|
|
if (req.status != 200 || !req.responseXML) {
|
|
this.oDbg.log("initial response broken (status: "+req.status+")",1);
|
|
this._handleEvent('onerror',JSJaCError('503','cancel','service-unavailable'));
|
|
return;
|
|
}
|
|
var body = req.responseXML.documentElement;
|
|
|
|
if (!body || body.tagName != 'body' || body.namespaceURI != 'http://jabber.org/protocol/httpbind') {
|
|
this.oDbg.log("no body element or incorrect body in initial response",1);
|
|
this._handleEvent("onerror",JSJaCError("500","wait","internal-service-error"));
|
|
return;
|
|
}
|
|
|
|
// Check for errors from the server
|
|
if (body.getAttribute("type") == "terminate") {
|
|
this.oDbg.log("invalid response:\n" + req.responseText,1);
|
|
clearTimeout(this._timeout); // remove timer
|
|
this._connected = false;
|
|
this.oDbg.log("Disconnected.",1);
|
|
this._handleEvent('ondisconnect');
|
|
this._handleEvent('onerror',JSJaCError('503','cancel','service-unavailable'));
|
|
return;
|
|
}
|
|
|
|
// get session ID
|
|
this._sid = body.getAttribute('sid');
|
|
this.oDbg.log("got sid: "+this._sid,2);
|
|
|
|
// get attributes from response body
|
|
if (body.getAttribute('polling'))
|
|
this._min_polling = body.getAttribute('polling');
|
|
|
|
if (body.getAttribute('inactivity'))
|
|
this._inactivity = body.getAttribute('inactivity');
|
|
|
|
if (body.getAttribute('requests'))
|
|
this._setHold(body.getAttribute('requests')-1);
|
|
this.oDbg.log("set hold to " + this._getHold(),2);
|
|
|
|
if (body.getAttribute('ver'))
|
|
this._bosh_version = body.getAttribute('ver');
|
|
|
|
if (body.getAttribute('maxpause'))
|
|
this._pause = Number.min(body.getAttribute('maxpause'), JSJACHBC_MAXPAUSE);
|
|
|
|
// must be done after response attributes have been collected
|
|
this.setPollInterval(this._timerval);
|
|
|
|
/* start sending from queue for not polling connections */
|
|
this._connected = true;
|
|
|
|
this._inQto = setInterval(JSJaC.bind(this._checkInQ, this),
|
|
JSJAC_CHECKINQUEUEINTERVAL);
|
|
this._interval= setInterval(JSJaC.bind(this._checkQueue, this),
|
|
JSJAC_CHECKQUEUEINTERVAL);
|
|
|
|
/* wait for initial stream response to extract streamid needed
|
|
* for digest auth
|
|
*/
|
|
this._getStreamID(req);
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCHttpBindingConnection.prototype._parseResponse = function(req) {
|
|
if (!this.connected() || !req)
|
|
return null;
|
|
|
|
var r = req.r; // the XmlHttpRequest
|
|
|
|
try {
|
|
if (r.status == 404 || r.status == 403) {
|
|
// connection manager killed session
|
|
this._abort();
|
|
return null;
|
|
}
|
|
|
|
if (r.status != 200 || !r.responseXML) {
|
|
this._errcnt++;
|
|
var errmsg = "invalid response ("+r.status+"):\n" + r.getAllResponseHeaders()+"\n"+r.responseText;
|
|
if (!r.responseXML)
|
|
errmsg += "\nResponse failed to parse!";
|
|
this.oDbg.log(errmsg,1);
|
|
if (this._errcnt > JSJAC_ERR_COUNT) {
|
|
// abort
|
|
this._abort();
|
|
return null;
|
|
}
|
|
|
|
if (this.connected()) {
|
|
this.oDbg.log("repeating ("+this._errcnt+")",1);
|
|
this._setStatus('proto_error_fallback');
|
|
|
|
// schedule next tick
|
|
setTimeout(JSJaC.bind(this._resume, this),
|
|
this.getPollInterval());
|
|
}
|
|
|
|
return null;
|
|
}
|
|
} catch (e) {
|
|
this.oDbg.log("XMLHttpRequest error: status not available", 1);
|
|
this._errcnt++;
|
|
if (this._errcnt > JSJAC_ERR_COUNT) {
|
|
// abort
|
|
this._abort();
|
|
} else {
|
|
if (this.connected()) {
|
|
this.oDbg.log("repeating ("+this._errcnt+")",1);
|
|
|
|
this._setStatus('proto_error_fallback');
|
|
|
|
// schedule next tick
|
|
setTimeout(JSJaC.bind(this._resume, this),
|
|
this.getPollInterval());
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
var body = r.responseXML.documentElement;
|
|
if (!body || body.tagName != 'body' ||
|
|
body.namespaceURI != 'http://jabber.org/protocol/httpbind') {
|
|
this.oDbg.log("invalid response:\n" + r.responseText,1);
|
|
|
|
clearTimeout(this._timeout); // remove timer
|
|
clearInterval(this._interval);
|
|
clearInterval(this._inQto);
|
|
|
|
this._connected = false;
|
|
this.oDbg.log("Disconnected.",1);
|
|
this._handleEvent('ondisconnect');
|
|
|
|
this._setStatus('internal_server_error');
|
|
this._handleEvent('onerror',
|
|
JSJaCError('500','wait','internal-server-error'));
|
|
|
|
return null;
|
|
}
|
|
|
|
if (typeof(req.rid) != 'undefined' && this._last_requests[req.rid]) {
|
|
if (this._last_requests[req.rid].handled) {
|
|
this.oDbg.log("already handled "+req.rid,2);
|
|
return null;
|
|
} else
|
|
this._last_requests[req.rid].handled = true;
|
|
}
|
|
|
|
|
|
// Check for errors from the server
|
|
if (body.getAttribute("type") == "terminate") {
|
|
// read condition
|
|
var condition = body.getAttribute('condition');
|
|
|
|
if (condition != "item-not-found") {
|
|
this.oDbg.log("session terminated:\n" + r.responseText,1);
|
|
|
|
clearTimeout(this._timeout); // remove timer
|
|
clearInterval(this._interval);
|
|
clearInterval(this._inQto);
|
|
|
|
try {
|
|
removeDB('jsjac', 'state');
|
|
} catch (e) {}
|
|
|
|
this._connected = false;
|
|
|
|
if (condition == "remote-stream-error")
|
|
if (body.getElementsByTagName("conflict").length > 0)
|
|
this._setStatus("session-terminate-conflict");
|
|
if (condition == null)
|
|
condition = 'session-terminate';
|
|
this._handleEvent('onerror',JSJaCError('503','cancel',condition));
|
|
|
|
this.oDbg.log("Aborting remaining connections",4);
|
|
|
|
for (var i=0; i<this._hold+1; i++) {
|
|
try {
|
|
this._req[i].r.abort();
|
|
} catch(e) { this.oDbg.log(e, 1); }
|
|
}
|
|
|
|
this.oDbg.log("parseResponse done with terminating", 3);
|
|
|
|
this.oDbg.log("Disconnected.",1);
|
|
this._handleEvent('ondisconnect');
|
|
} else {
|
|
this._errcnt++;
|
|
if (this._errcnt > JSJAC_ERR_COUNT)
|
|
this._abort();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// no error
|
|
this._errcnt = 0;
|
|
return r.responseXML.documentElement;
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCHttpBindingConnection.prototype._reInitStream = function(cb) {
|
|
// tell http binding to reinit stream with/before next request
|
|
this._reinit = true;
|
|
|
|
this._sendEmpty(this._prepReInitStreamWait(cb));
|
|
};
|
|
|
|
|
|
JSJaCHttpBindingConnection.prototype._prepReInitStreamWait = function(cb) {
|
|
return JSJaC.bind(function(req) {
|
|
this._reInitStreamWait(req, cb);
|
|
}, this);
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCHttpBindingConnection.prototype._reInitStreamWait = function(req, cb) {
|
|
this.oDbg.log("checking for stream features");
|
|
var doc = req.responseXML.documentElement;
|
|
this.oDbg.log(doc);
|
|
if (doc.getElementsByTagNameNS) {
|
|
this.oDbg.log("checking with namespace");
|
|
var features = doc.getElementsByTagNameNS('http://etherx.jabber.org/streams',
|
|
'features').item(0);
|
|
if (features) {
|
|
var bind = features.getElementsByTagNameNS('urn:ietf:params:xml:ns:xmpp-bind',
|
|
'bind').item(0);
|
|
}
|
|
} else {
|
|
var featuresNL = doc.getElementsByTagName('stream:features');
|
|
for (var i=0, l=featuresNL.length; i<l; i++) {
|
|
if (featuresNL.item(i).namespaceURI == 'http://etherx.jabber.org/streams' ||
|
|
featuresNL.item(i).getAttribute('xmlns') ==
|
|
'http://etherx.jabber.org/streams') {
|
|
var features = featuresNL.item(i);
|
|
break;
|
|
}
|
|
}
|
|
if (features) {
|
|
var bind = features.getElementsByTagName('bind');
|
|
for (var i=0, l=bind.length; i<l; i++) {
|
|
if (bind.item(i).namespaceURI == 'urn:ietf:params:xml:ns:xmpp-bind' ||
|
|
bind.item(i).getAttribute('xmlns') ==
|
|
'urn:ietf:params:xml:ns:xmpp-bind') {
|
|
bind = bind.item(i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this.oDbg.log(features);
|
|
this.oDbg.log(bind);
|
|
|
|
if (features) {
|
|
if (bind) {
|
|
cb();
|
|
} else {
|
|
this.oDbg.log("no bind feature - giving up",1);
|
|
this._handleEvent('onerror',JSJaCError('503','cancel',"service-unavailable"));
|
|
this._connected = false;
|
|
this.oDbg.log("Disconnected.",1);
|
|
this._handleEvent('ondisconnect');
|
|
}
|
|
} else {
|
|
// wait
|
|
this._sendEmpty(this._prepReInitStreamWait(cb));
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCHttpBindingConnection.prototype._resume = function() {
|
|
/* make sure to repeat last request as we can be sure that
|
|
* it had failed (only if we're not using the 'pause' attribute
|
|
*/
|
|
if (this._pause == 0 && this._rid >= this._last_rid)
|
|
this._rid = this._last_rid-1;
|
|
|
|
this._process();
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCHttpBindingConnection.prototype._setHold = function(hold) {
|
|
if (!hold || isNaN(hold) || hold < 0)
|
|
hold = 0;
|
|
else if (hold > JSJACHBC_MAX_HOLD)
|
|
hold = JSJACHBC_MAX_HOLD;
|
|
this._hold = hold;
|
|
return this._hold;
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCHttpBindingConnection.prototype._setupRequest = function(async) {
|
|
var req = new Object();
|
|
var r = XmlHttp.create();
|
|
try {
|
|
r.open("POST",this._httpbase,async);
|
|
r.setRequestHeader('Content-Type','text/xml; charset=utf-8');
|
|
} catch(e) { this.oDbg.log(e,1); }
|
|
req.r = r;
|
|
this._rid++;
|
|
req.rid = this._rid;
|
|
return req;
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
JSJaCHttpBindingConnection.prototype._suspend = function() {
|
|
if (this._pause == 0)
|
|
return; // got nothing to do
|
|
|
|
var slot = this._getFreeSlot();
|
|
// Intentionally synchronous
|
|
this._req[slot] = this._setupRequest(false);
|
|
|
|
var reqstr = "<body xml:lang='"+XML_LANG+"' pause='"+this._pause+"' xmlns='http://jabber.org/protocol/httpbind' sid='"+this._sid+"' rid='"+this._rid+"'";
|
|
if (JSJAC_HAVEKEYS) {
|
|
reqstr += " key='"+this._keys.getKey()+"'";
|
|
if (this._keys.lastKey()) {
|
|
this._keys = new JSJaCKeys(hex_sha1,this.oDbg);
|
|
reqstr += " newkey='"+this._keys.getKey()+"'";
|
|
}
|
|
|
|
}
|
|
reqstr += ">";
|
|
|
|
while (this._pQueue.length) {
|
|
var curNode = this._pQueue[0];
|
|
reqstr += curNode;
|
|
this._pQueue = this._pQueue.slice(1,this._pQueue.length);
|
|
}
|
|
|
|
//reqstr += "<presence type='unavailable' xmlns='jabber:client'/>";
|
|
reqstr += "</body>";
|
|
|
|
this.oDbg.log("Disconnecting: " + reqstr,4);
|
|
this._req[slot].r.send(reqstr);
|
|
};
|