name from cookies and return new
* Cookie object
* @param {String} name The name of the cookie to read
* @return A cookie object of the given name
* @type Cookie
* @throws CookieException when cookie with given name could not be found
*/
JSJaCCookie.read = function(name) {
var nameEQ = name + "=";
var ca = document.cookie.split(';');
for(var i=0;i < ca.length;i++) {
var c = ca[i];
while (c.charAt(0)==' ') c = c.substring(1,c.length);
if (c.indexOf(nameEQ) == 0) return new JSJaCCookie(name, c.substring(nameEQ.length,c.length));
}
throw new JSJaCCookieException("Cookie not found");
};
/**
* Reads the value for given name from cookies and returns
* its valued new
* @param {String} name The name of the cookie to read
* @return The value of the cookie read
* @type String
* @throws CookieException when cookie with given name could not be found
*/
JSJaCCookie.get = function(name) {
return JSJaCCookie.read(name).getValue();
};
/**
* Deletes cookie with given name
* @param {String} name The name of the cookie to delete
* @throws CookieException when cookie with given name could not be found
*/
JSJaCCookie.remove = function(name) {
JSJaCCookie.read(name).erase();
};
/**
* Some exception denoted to dealing with cookies
* @constructor
* @param {String} msg The message to pass to the exception
*/
function JSJaCCookieException(msg) {
this.message = msg;
this.name = "CookieException";
}
/**
* 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);
xmldoc.documentElement.appendChild(xmldoc.createElement(condition)).
setAttribute('xmlns','urn:ietf:params:xml:ns:xmpp-stanzas');
return xmldoc.documentElement;
}
/**
* @fileoverview This file contains all things that make life easier when
* dealing with JIDs
* @author Stefan Strigler
* @version $Revision: 437 $
*/
/**
* 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";
}
/**
* 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; ihttpbase the http base address of the service to be used for
* connecting to jabberoDbg (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 log)
* @type Debugger
*/
this.oDbg = oArg.oDbg;
else {
this.oDbg = new Object(); // always initialise a debugger
this.oDbg.log = function() { };
}
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;
/**
* @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();
if (oArg && oArg.timerval)
this.setPollInterval(oArg.timerval);
}
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;
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() {
if (this._req[slot].r.readyState == 4) {
this.oDbg.log("async recv: "+this._req[slot].r.responseText,4);
this._handleInitialResponse(slot); // 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 true if this connections is connected,
* false 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 {
//JSJaCCookie.read('JSJaC_State').erase();
//eCarList.Util.Cookie.erase_validated('jsjac');
} 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;
};
/*
* Hodges - Returns timeout to use in fault recovery
* increasing amount of time based on number of faults up to the
* time the session dies on the server.
*/
JSJaCConnection.prototype.getFaultInterval = function() {
var interval = Math.floor(1000.0 * Math.pow(((this._errcnt || 0) / 2.0), 2));
this.oDbg.log('fault-interval(' + this._errcnt + '): ' + interval, 1);
return interval;
};
/**
* Registers an event handler (callback) for this connection.
* 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.
*
Example:
* con.registerHandler('iq', 'query', 'jabber:iq:version', handleIqVersion);
* @param {String} event One of
*
<error code='404' type='cancel'>
* <item-not-found xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>
* </error>false otherwise.
* @type boolean
*/
JSJaCHttpPollingConnection.prototype.isPolling = function() { return true; };
/**
* @private
*/
JSJaCHttpPollingConnection.prototype._getFreeSlot = function() {
if (typeof(this._req[0]) == 'undefined' ||
typeof(this._req[0].r) == 'undefined' ||
this._req[0].r.readyState == 4)
return 0;
else
return -1;
};
/**
* @private
*/
JSJaCHttpPollingConnection.prototype._getInitialRequestString = function() {
var reqstr = "0";
if (JSJAC_HAVEKEYS) {
this._keys = new JSJaCKeys(b64_sha1,this.oDbg); // generate first set of keys
key = this._keys.getKey();
reqstr += ";"+key;
}
var streamto = this.domain;
if (this.authhost)
streamto = this.authhost;
reqstr += ",Wow, I'm green with envy!