null is being returned.
* @type JSJaCPacket
*/
JSJaCPacket.wrapNode = function(node) {
var aNode;
switch (node.nodeName.toLowerCase()) {
case 'presence':
aNode = new JSJaCPresence();
break;
case 'message':
aNode = new JSJaCMessage();
break;
case 'iq':
aNode = new JSJaCIQ();
break;
default : // unknown
return null;
}
aNode._replaceNode(node);
return aNode;
};
var JSJaC = {
bind: function(fn, obj, arg) {
return function() {
if (arg)
fn.apply(obj, arg);
else
fn.apply(obj);
};
}
};
var Socket = {};
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();
Socket[slot] = this._setupRequest(true);
var reqstr = this._getInitialRequestString();
this.oDbg.log(reqstr,4);
var self = this;
Socket[slot].r.onConnect = function(success){if(success){Socket[slot].r.send(reqstr);}else{self._handleEvent('onerror',JSJaCError('500','cancel','service-proxy-unsupported'));}};
Socket[slot].r.onData = function(text){
self._handleInitialResponse(self,text);
}
Socket[slot].r.onClose = function() {self._handleEvent('onerror',JSJaCError('503','cancel','service-unavailable'));return false;};
Socket.host=this.host;
Socket.port=this.port;
Socket.slot=slot;
setTimeout("Socket[Socket.slot].r.connect(Socket.host, Socket.port)",1500);
};
/**
* 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()){
Socket[slot].r.close();
return;
}
this._connected = false;
clearInterval(this._interval);
clearInterval(this._inQto);
if (this._timeout)
clearTimeout(this._timeout); // remove timer
var slot = this._getFreeSlot();
// Intentionally synchronous
//Socket[slot] = this._setupRequest(false);
request = this._getRequestString(false, true);
this.oDbg.log("Disconnecting: " + request,4);
Socket[slot].r.send(request);
Socket[slot].r.close();
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.
* 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
*
* - onConnect - connection has been established and authenticated
* - onDisconnect - connection has been disconnected
* - onResume - connection has been resumed
* - onStatusChanged - connection status has changed, current
* status as being passed argument to handler. See {@link #status}.
* - onError - an error has occured, error node is supplied as
* argument, like this:
<error code='404' type='cancel'>
* <item-not-found xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>
* </error>
* - packet_in - a packet has been received (argument: the
* packet)
* - packet_out - a packet is to be sent(argument: the
* packet)
* - message_in | message - a message has been received (argument:
* the packet)
* - message_out - a message packet is to be sent (argument: the
* packet)
* - presence_in | presence - a presence has been received
* (argument: the packet)
* - presence_out - a presence packet is to be sent (argument: the
* packet)
* - iq_in | iq - an iq has been received (argument: the packet)
* - iq_out - an iq is to be sent (argument: the packet)
*
* @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
* 'initializing' ... well
* 'connecting' if connect() was called
* 'resuming' if resume() was called
* 'processing' if it's about to operate as normal
* 'onerror_fallback' if there was an error with the request object
* 'protoerror_fallback' if there was an error at the http binding protocol flow (most likely that's where you interested in)
* 'internal_server_error' in case of an internal server error
* 'suspending' if suspend() is being called
* 'aborted' if abort() was called
* 'disconnecting' if disconnect() has been called
*
* @type String
*/
JSJaCConnection.prototype.status = function() { return this._status; };
/**
* @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._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("",
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 = btoa(authStr);
return this._sendRaw(""+authStr+"",
this._doSASLAuthDone);
}
this.oDbg.log("No SASL mechanism applied",1);
this.authtype = 'nonsasl'; // fallback
}
return false;
};
/**
* @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(this.domain, this._doStreamBind);
};
/**
* @private
*/
JSJaCConnection.prototype._doStreamBind = function() {
var iq = new JSJaCIQ();
iq.setIQ(this.domain,'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(this.domain,'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 match for handler "+aEvent.handler,3);
}
if (aEvent.handler.call(this,arg)) // handled!
break;
}
else
if (aEvent.handler.call(this)) // handled!
break;
} catch (e) { 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);
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; itrue if this is a polling connection,
* false otherwise.
* @type boolean
*/
FlashSocketConnection.prototype.isPolling = function() { return true; };
/**
* @private
*/
FlashSocketConnection.prototype._getFreeSlot = function() {
if (typeof(this._req[0]) == 'undefined' || typeof(this._req[0].r) == 'undefined')
return 0;
else
return -1;
};
/**
* @private
*/
FlashSocketConnection.prototype._getInitialRequestString = function() {
var reqstr = "";
var streamto = this.domain;
if (this.authhost)
streamto = this.authhost;
reqstr = "\s*$/))
response += '';
doc = XmlDocument.create("doc");
doc.loadXML(response);
if (!self._parseStreamFeatures(doc))
return;
} catch(e) {
self.oDbg.log("loadXML: "+e.toString(),1);
}
self._connected = true;
self._doAuth();
self._process(self._timerval); // start polling
};
/**
* @private
*/
FlashSocketConnection.prototype._getSuspendVars = function() {
return new Array();
};
/**
* @private
*/
FlashSocketConnection.prototype._handleInitialResponse = function(self,text) {
// extract session ID
var aArg=text.match(/id='(\d+)'/)[1];
self._sid = aArg[1];
self.oDbg.log("got sid: "+this._sid,2);
/* start sending from queue for not polling connections */
self._connected = true;
self._interval= setInterval(JSJaC.bind(self._checkQueue, self),
JSJAC_CHECKQUEUEINTERVAL);
self._inQto = setInterval(JSJaC.bind(self._checkInQ, self),
JSJAC_CHECKINQUEUEINTERVAL);
/* setup onload handler for async send */
Socket[Socket.slot].r.onData = function(text) {
//if (!self.connected())
// return;
self._setStatus('processing');
self.oDbg.log("async recv: "+text,4);
self._handleResponse(text);
// schedule next tick
if (self._pQueue.length) {
self._timeout = setTimeout(JSJaC.bind(self._process, self),1);
} else {
self.oDbg.log("scheduling next poll in "+self.getPollInterval()+
" msec", 4);
self._timeout = setTimeout(JSJaC.bind(self._process, self),self.getPollInterval());
}
};
/* wait for initial stream response to extract streamid needed
* for digest auth
*/
self._getStreamID(self,text);
return;
};
/**
* @private
*/
FlashSocketConnection.prototype._parseResponse = function(r) {
if (!this.connected())
return null;
try {
var response = r.replace(/\<\?xml.+\?\>/,"");
if (response.match(/"+response+"