网站上有很多Openfire Web方案，之前想用Smack 但是jar包支持客户端版本的，还有JDK版本问题 一直没调试成功 估计成功的方法只能拜读源码进行修改了。
SparkWeb 官网代码很久没维护 CSDN上下来个版本但jar包路径不对 花了不少时间总算能跑起来，不过版本是flex3版本，太老了 自己花精力升级有点费时间呀
最后采用存脚本开发Strophejs，下面网站写的很详细
学习的网站：http://www.dotblogs.com.tw/sungnoone/archive/2014/06/20/145642.aspx
Strophejs中文发送到服务器端老会出现乱码问题，这个问题网上也没好的解决方案，在这里我分享下我的方法。
1、修改Strophe.js
添加chencode中文编码，cht IQ请求节点中文内容，添加utf16to8方法
1 /** File: strophe.js
2 * A JavaScript library for XMPP BOSH/XMPP over Websocket.
3 *
4 * This is the JavaScript version of the Strophe library. Since JavaScript
5 * had no facilities for persistent TCP connections, this library uses
6 * Bidirectional-streams Over Synchronous HTTP (BOSH) to emulate
7 * a persistent, stateful, two-way connection to an XMPP server. More
8 * information on BOSH can be found in XEP 124.
9 *
10 * This version of Strophe also works with WebSockets.
11 * For more information on XMPP-over WebSocket see this RFC:
12 * http://tools.ietf.org/html/rfc7395
13 */
14
15 /* All of the Strophe globals are defined in this special function below so
16 * that references to the globals become closures. This will ensure that
17 * on page reload, these references will still be available to callbacks
18 * that are still executing.
19 */
20
21 /* jshint ignore:start */
22 (function (callback) {
23 /* jshint ignore:end */
24
25 // This code was written by Tyler Akins and has been placed in the
26 // public domain. It would be nice if you left this header intact.
27 // Base64 code from Tyler Akins -- http://rumkin.com
28
29 (function (root, factory) {
30 if (typeof define === ‘function‘ && define.amd) {
31 define(‘strophe-base64‘, function () {
32 return factory();
33 });
34 } else {
35 // Browser globals
36 root.Base64 = factory();
37 }
38 }(this, function () {
39 var keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
40
41 var obj = {
42 /**
43 * Encodes a string in base64
44 * @param {String} input The string to encode in base64.
45 */
46 encode: function (input) {
47 var output = "";
48 var chr1, chr2, chr3;
49 var enc1, enc2, enc3, enc4;
50 var i = 0;
51
52 do {
53 chr1 = input.charCodeAt(i++);
54 chr2 = input.charCodeAt(i++);
55 chr3 = input.charCodeAt(i++);
56
57 enc1 = chr1 >> 2;
58 enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
59 enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
60 enc4 = chr3 & 63;
61
62 if (isNaN(chr2)) {
63 enc2 = ((chr1 & 3) << 4);
64 enc3 = enc4 = 64;
65 } else if (isNaN(chr3)) {
66 enc4 = 64;
67 }
68
69 output = output + keyStr.charAt(enc1) + keyStr.charAt(enc2) +
70 keyStr.charAt(enc3) + keyStr.charAt(enc4);
71 } while (i < input.length);
72
73 return output;
74 },
75 chencode:function(input) {
76 input = utf16to8(input);
77 var output = "";
78 var chr1, chr2, chr3;
79 var enc1, enc2, enc3, enc4;
80 var i = 0;
81 do {
82 chr1 = input.charCodeAt(i++);
83 chr2 = input.charCodeAt(i++);
84 chr3 = input.charCodeAt(i++);
85
86 enc1 = chr1 >> 2;
87 enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
88 enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
89 enc4 = chr3 & 63;
90
91 if (isNaN(chr2)) {
92 enc2 = ((chr1 & 3) << 4);
93 enc3 = enc4 = 64;
94 } else if (isNaN(chr3)) {
95 enc4 = 64;
96 }
97
98 output = output + keyStr.charAt(enc1) + keyStr.charAt(enc2) +
99 keyStr.charAt(enc3) + keyStr.charAt(enc4);
100 } while (i < input.length);
101 return output;
102 },
103 /**
104 * Decodes a base64 string.
105 * @param {String} input The string to decode.
106 */
107 decode: function (input) {
108 var output = "";
109 var chr1, chr2, chr3;
110 var enc1, enc2, enc3, enc4;
111 var i = 0;
112
113 // remove all characters that are not A-Z, a-z, 0-9, +, /, or =
114 input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
115
116 do {
117 enc1 = keyStr.indexOf(input.charAt(i++));
118 enc2 = keyStr.indexOf(input.charAt(i++));
119 enc3 = keyStr.indexOf(input.charAt(i++));
120 enc4 = keyStr.indexOf(input.charAt(i++));
121
122 chr1 = (enc1 << 2) | (enc2 >> 4);
123 chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
124 chr3 = ((enc3 & 3) << 6) | enc4;
125
126 output = output + String.fromCharCode(chr1);
127
128 if (enc3 != 64) {
129 output = output + String.fromCharCode(chr2);
130 }
131 if (enc4 != 64) {
132 output = output + String.fromCharCode(chr3);
133 }
134 } while (i < input.length);
135
136 return output;
137 }
138 };
139 return obj;
140 }));
141
142 /*
143 * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
144 * in FIPS PUB 180-1
145 * Version 2.1a Copyright Paul Johnston 2000 - 2002.
146 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
147 * Distributed under the BSD License
148 * See http://pajhome.org.uk/crypt/md5 for details.
149 */
150
151 /* jshint undef: true, unused: true:, noarg: true, latedef: true */
152 /* global define */
153
154 /* Some functions and variables have been stripped for use with Strophe */
155
156 (function (root, factory) {
157 if (typeof define === ‘function‘ && define.amd) {
158 define(‘strophe-sha1‘, function () {
159 return factory();
160 });
161 } else {
162 // Browser globals
163 root.SHA1 = factory();
164 }
165 }(this, function () {
166
167 /*
168 * Calculate the SHA-1 of an array of big-endian words, and a bit length
169 */
170 function core_sha1(x, len)
171 {
172 /* append padding */
173 x[len >> 5] |= 0x80 << (24 - len % 32);
174 x[((len + 64 >> 9) << 4) + 15] = len;
175
176 var w = new Array(80);
177 var a = 1732584193;
178 var b = -271733879;
179 var c = -1732584194;
180 var d = 271733878;
181 var e = -1009589776;
182
183 var i, j, t, olda, oldb, oldc, oldd, olde;
184 for (i = 0; i < x.length; i += 16)
185 {
186 olda = a;
187 oldb = b;
188 oldc = c;
189 oldd = d;
190 olde = e;
191
192 for (j = 0; j < 80; j++)
193 {
194 if (j < 16) { w[j] = x[i + j]; }
195 else { w[j] = rol(w[j-3] ^ w[j-8] ^ w[j-14] ^ w[j-16], 1); }
196 t = safe_add(safe_add(rol(a, 5), sha1_ft(j, b, c, d)),
197 safe_add(safe_add(e, w[j]), sha1_kt(j)));
198 e = d;
199 d = c;
200 c = rol(b, 30);
201 b = a;
202 a = t;
203 }
204
205 a = safe_add(a, olda);
206 b = safe_add(b, oldb);
207 c = safe_add(c, oldc);
208 d = safe_add(d, oldd);
209 e = safe_add(e, olde);
210 }
211 return [a, b, c, d, e];
212 }
213
214 /*
215 * Perform the appropriate triplet combination function for the current
216 * iteration
217 */
218 function sha1_ft(t, b, c, d)
219 {
220 if (t < 20) { return (b & c) | ((~b) & d); }
221 if (t < 40) { return b ^ c ^ d; }
222 if (t < 60) { return (b & c) | (b & d) | (c & d); }
223 return b ^ c ^ d;
224 }
225
226 /*
227 * Determine the appropriate additive constant for the current iteration
228 */
229 function sha1_kt(t)
230 {
231 return (t < 20) ? 1518500249 : (t < 40) ? 1859775393 :
232 (t < 60) ? -1894007588 : -899497514;
233 }
234
235 /*
236 * Calculate the HMAC-SHA1 of a key and some data
237 */
238 function core_hmac_sha1(key, data)
239 {
240 var bkey = str2binb(key);
241 if (bkey.length > 16) { bkey = core_sha1(bkey, key.length * 8); }
242
243 var ipad = new Array(16), opad = new Array(16);
244 for (var i = 0; i < 16; i++)
245 {
246 ipad[i] = bkey[i] ^ 0x36363636;
247 opad[i] = bkey[i] ^ 0x5C5C5C5C;
248 }
249
250 var hash = core_sha1(ipad.concat(str2binb(data)), 512 + data.length * 8);
251 return core_sha1(opad.concat(hash), 512 + 160);
252 }
253
254 /*
255 * Add integers, wrapping at 2^32. This uses 16-bit operations internally
256 * to work around bugs in some JS interpreters.
257 */
258 function safe_add(x, y)
259 {
260 var lsw = (x & 0xFFFF) + (y & 0xFFFF);
261 var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
262 return (msw << 16) | (lsw & 0xFFFF);
263 }
264
265 /*
266 * Bitwise rotate a 32-bit number to the left.
267 */
268 function rol(num, cnt)
269 {
270 return (num << cnt) | (num >>> (32 - cnt));
271 }
272
273 /*
274 * Convert an 8-bit or 16-bit string to an array of big-endian words
275 * In 8-bit function, characters >255 have their hi-byte silently ignored.
276 */
277 function str2binb(str)
278 {
279 var bin = [];
280 var mask = 255;
281 for (var i = 0; i < str.length * 8; i += 8)
282 {
283 bin[i>>5] |= (str.charCodeAt(i / 8) & mask) << (24 - i%32);
284 }
285 return bin;
286 }
287
288 /*
289 * Convert an array of big-endian words to a string
290 */
291 function binb2str(bin)
292 {
293 var str = "";
294 var mask = 255;
295 for (var i = 0; i < bin.length * 32; i += 8)
296 {
297 str += String.fromCharCode((bin[i>>5] >>> (24 - i%32)) & mask);
298 }
299 return str;
300 }
301
302 /*
303 * Convert an array of big-endian words to a base-64 string
304 */
305 function binb2b64(binarray)
306 {
307 var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
308 var str = "";
309 var triplet, j;
310 for (var i = 0; i < binarray.length * 4; i += 3)
311 {
312 triplet = (((binarray[i >> 2] >> 8 * (3 - i %4)) & 0xFF) << 16) |
313 (((binarray[i+1 >> 2] >> 8 * (3 - (i+1)%4)) & 0xFF) << 8 ) |
314 ((binarray[i+2 >> 2] >> 8 * (3 - (i+2)%4)) & 0xFF);
315 for (j = 0; j < 4; j++)
316 {
317 if (i * 8 + j * 6 > binarray.length * 32) { str += "="; }
318 else { str += tab.charAt((triplet >> 6*(3-j)) & 0x3F); }
319 }
320 }
321 return str;
322 }
323
324 /*
325 * These are the functions you‘ll usually want to call
326 * They take string arguments and return either hex or base-64 encoded strings
327 */
328 return {
329 b64_hmac_sha1: function (key, data){ return binb2b64(core_hmac_sha1(key, data)); },
330 b64_sha1: function (s) { return binb2b64(core_sha1(str2binb(s),s.length * 8)); },
331 binb2str: binb2str,
332 core_hmac_sha1: core_hmac_sha1,
333 str_hmac_sha1: function (key, data){ return binb2str(core_hmac_sha1(key, data)); },
334 str_sha1: function (s) { return binb2str(core_sha1(str2binb(s),s.length * 8)); },
335 };
336 }));
337
338 /*
339 * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
340 * Digest Algorithm, as defined in RFC 1321.
341 * Version 2.1 Copyright (C) Paul Johnston 1999 - 2002.
342 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
343 * Distributed under the BSD License
344 * See http://pajhome.org.uk/crypt/md5 for more info.
345 */
346
347 /*
348 * Everything that isn‘t used by Strophe has been stripped here!
349 */
350
351 (function (root, factory) {
352 if (typeof define === ‘function‘ && define.amd) {
353 define(‘strophe-md5‘, function () {
354 return factory();
355 });
356 } else {
357 // Browser globals
358 root.MD5 = factory();
359 }
360 }(this, function (b) {
361 /*
362 * Add integers, wrapping at 2^32. This uses 16-bit operations internally
363 * to work around bugs in some JS interpreters.
364 */
365 var safe_add = function (x, y) {
366 var lsw = (x & 0xFFFF) + (y & 0xFFFF);
367 var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
368 return (msw << 16) | (lsw & 0xFFFF);
369 };
370
371 /*
372 * Bitwise rotate a 32-bit number to the left.
373 */
374 var bit_rol = function (num, cnt) {
375 return (num << cnt) | (num >>> (32 - cnt));
376 };
377
378 /*
379 * Convert a string to an array of little-endian words
380 */
381 var str2binl = function (str) {
382 var bin = [];
383 for(var i = 0; i < str.length * 8; i += 8)
384 {
385 bin[i>>5] |= (str.charCodeAt(i / 8) & 255) << (i%32);
386 }
387 return bin;
388 };
389
390 /*
391 * Convert an array of little-endian words to a string
392 */
393 var binl2str = function (bin) {
394 var str = "";
395 for(var i = 0; i < bin.length * 32; i += 8)
396 {
397 str += String.fromCharCode((bin[i>>5] >>> (i % 32)) & 255);
398 }
399 return str;
400 };
401
402 /*
403 * Convert an array of little-endian words to a hex string.
404 */
405 var binl2hex = function (binarray) {
406 var hex_tab = "0123456789abcdef";
407 var str = "";
408 for(var i = 0; i < binarray.length * 4; i++)
409 {
410 str += hex_tab.charAt((binarray[i>>2] >> ((i%4)*8+4)) & 0xF) +
411 hex_tab.charAt((binarray[i>>2] >> ((i%4)*8 )) & 0xF);
412 }
413 return str;
414 };
415
416 /*
417 * These functions implement the four basic operations the algorithm uses.
418 */
419 var md5_cmn = function (q, a, b, x, s, t) {
420 return safe_add(bit_rol(safe_add(safe_add(a, q),safe_add(x, t)), s),b);
421 };
422
423 var md5_ff = function (a, b, c, d, x, s, t) {
424 return md5_cmn((b & c) | ((~b) & d), a, b, x, s, t);
425 };
426
427 var md5_gg = function (a, b, c, d, x, s, t) {
428 return md5_cmn((b & d) | (c & (~d)), a, b, x, s, t);
429 };
430
431 var md5_hh = function (a, b, c, d, x, s, t) {
432 return md5_cmn(b ^ c ^ d, a, b, x, s, t);
433 };
434
435 var md5_ii = function (a, b, c, d, x, s, t) {
436 return md5_cmn(c ^ (b | (~d)), a, b, x, s, t);
437 };
438
439 /*
440 * Calculate the MD5 of an array of little-endian words, and a bit length
441 */
442 var core_md5 = function (x, len) {
443 /* append padding */
444 x[len >> 5] |= 0x80 << ((len) % 32);
445 x[(((len + 64) >>> 9) << 4) + 14] = len;
446
447 var a = 1732584193;
448 var b = -271733879;
449 var c = -1732584194;
450 var d = 271733878;
451
452 var olda, oldb, oldc, oldd;
453 for (var i = 0; i < x.length; i += 16)
454 {
455 olda = a;
456 oldb = b;
457 oldc = c;
458 oldd = d;
459
460 a = md5_ff(a, b, c, d, x[i+ 0], 7 , -680876936);
461 d = md5_ff(d, a, b, c, x[i+ 1], 12, -389564586);
462 c = md5_ff(c, d, a, b, x[i+ 2], 17, 606105819);
463 b = md5_ff(b, c, d, a, x[i+ 3], 22, -1044525330);
464 a = md5_ff(a, b, c, d, x[i+ 4], 7 , -176418897);
465 d = md5_ff(d, a, b, c, x[i+ 5], 12, 1200080426);
466 c = md5_ff(c, d, a, b, x[i+ 6], 17, -1473231341);
467 b = md5_ff(b, c, d, a, x[i+ 7], 22, -45705983);
468 a = md5_ff(a, b, c, d, x[i+ 8], 7 , 1770035416);
469 d = md5_ff(d, a, b, c, x[i+ 9], 12, -1958414417);
470 c = md5_ff(c, d, a, b, x[i+10], 17, -42063);
471 b = md5_ff(b, c, d, a, x[i+11], 22, -1990404162);
472 a = md5_ff(a, b, c, d, x[i+12], 7 , 1804603682);
473 d = md5_ff(d, a, b, c, x[i+13], 12, -40341101);
474 c = md5_ff(c, d, a, b, x[i+14], 17, -1502002290);
475 b = md5_ff(b, c, d, a, x[i+15], 22, 1236535329);
476
477 a = md5_gg(a, b, c, d, x[i+ 1], 5 , -165796510);
478 d = md5_gg(d, a, b, c, x[i+ 6], 9 , -1069501632);
479 c = md5_gg(c, d, a, b, x[i+11], 14, 643717713);
480 b = md5_gg(b, c, d, a, x[i+ 0], 20, -373897302);
481 a = md5_gg(a, b, c, d, x[i+ 5], 5 , -701558691);
482 d = md5_gg(d, a, b, c, x[i+10], 9 , 38016083);
483 c = md5_gg(c, d, a, b, x[i+15], 14, -660478335);
484 b = md5_gg(b, c, d, a, x[i+ 4], 20, -405537848);
485 a = md5_gg(a, b, c, d, x[i+ 9], 5 , 568446438);
486 d = md5_gg(d, a, b, c, x[i+14], 9 , -1019803690);
487 c = md5_gg(c, d, a, b, x[i+ 3], 14, -187363961);
488 b = md5_gg(b, c, d, a, x[i+ 8], 20, 1163531501);
489 a = md5_gg(a, b, c, d, x[i+13], 5 , -1444681467);
490 d = md5_gg(d, a, b, c, x[i+ 2], 9 , -51403784);
491 c = md5_gg(c, d, a, b, x[i+ 7], 14, 1735328473);
492 b = md5_gg(b, c, d, a, x[i+12], 20, -1926607734);
493
494 a = md5_hh(a, b, c, d, x[i+ 5], 4 , -378558);
495 d = md5_hh(d, a, b, c, x[i+ 8], 11, -2022574463);
496 c = md5_hh(c, d, a, b, x[i+11], 16, 1839030562);
497 b = md5_hh(b, c, d, a, x[i+14], 23, -35309556);
498 a = md5_hh(a, b, c, d, x[i+ 1], 4 , -1530992060);
499 d = md5_hh(d, a, b, c, x[i+ 4], 11, 1272893353);
500 c = md5_hh(c, d, a, b, x[i+ 7], 16, -155497632);
501 b = md5_hh(b, c, d, a, x[i+10], 23, -1094730640);
502 a = md5_hh(a, b, c, d, x[i+13], 4 , 681279174);
503 d = md5_hh(d, a, b, c, x[i+ 0], 11, -358537222);
504 c = md5_hh(c, d, a, b, x[i+ 3], 16, -722521979);
505 b = md5_hh(b, c, d, a, x[i+ 6], 23, 76029189);
506 a = md5_hh(a, b, c, d, x[i+ 9], 4 , -640364487);
507 d = md5_hh(d, a, b, c, x[i+12], 11, -421815835);
508 c = md5_hh(c, d, a, b, x[i+15], 16, 530742520);
509 b = md5_hh(b, c, d, a, x[i+ 2], 23, -995338651);
510
511 a = md5_ii(a, b, c, d, x[i+ 0], 6 , -198630844);
512 d = md5_ii(d, a, b, c, x[i+ 7], 10, 1126891415);
513 c = md5_ii(c, d, a, b, x[i+14], 15, -1416354905);
514 b = md5_ii(b, c, d, a, x[i+ 5], 21, -57434055);
515 a = md5_ii(a, b, c, d, x[i+12], 6 , 1700485571);
516 d = md5_ii(d, a, b, c, x[i+ 3], 10, -1894986606);
517 c = md5_ii(c, d, a, b, x[i+10], 15, -1051523);
518 b = md5_ii(b, c, d, a, x[i+ 1], 21, -2054922799);
519 a = md5_ii(a, b, c, d, x[i+ 8], 6 , 1873313359);
520 d = md5_ii(d, a, b, c, x[i+15], 10, -30611744);
521 c = md5_ii(c, d, a, b, x[i+ 6], 15, -1560198380);
522 b = md5_ii(b, c, d, a, x[i+13], 21, 1309151649);
523 a = md5_ii(a, b, c, d, x[i+ 4], 6 , -145523070);
524 d = md5_ii(d, a, b, c, x[i+11], 10, -1120210379);
525 c = md5_ii(c, d, a, b, x[i+ 2], 15, 718787259);
526 b = md5_ii(b, c, d, a, x[i+ 9], 21, -343485551);
527
528 a = safe_add(a, olda);
529 b = safe_add(b, oldb);
530 c = safe_add(c, oldc);
531 d = safe_add(d, oldd);
532 }
533 return [a, b, c, d];
534 };
535
536 var obj = {
537 /*
538 * These are the functions you‘ll usually want to call.
539 * They take string arguments and return either hex or base-64 encoded
540 * strings.
541 */
542 hexdigest: function (s) {
543 return binl2hex(core_md5(str2binl(s), s.length * 8));
544 },
545
546 hash: function (s) {
547 return binl2str(core_md5(str2binl(s), s.length * 8));
548 }
549 };
550 return obj;
551 }));
552
553 /*
554 This program is distributed under the terms of the MIT license.
555 Please see the LICENSE file for details.
556
557 Copyright 2006-2008, OGG, LLC
558 */
559
560 /* jshint undef: true, unused: true:, noarg: true, latedef: true */
561
562 /** PrivateFunction: Function.prototype.bind
563 * Bind a function to an instance.
564 *
565 * This Function object extension method creates a bound method similar
566 * to those in Python. This means that the ‘this‘ object will point
567 * to the instance you want. See
568 * <a href=‘https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function/bind‘>MDC‘s bind() documentation</a> and
569 * <a href=‘http://benjamin.smedbergs.us/blog/2007-01-03/bound-functions-and-function-imports-in-javascript/‘>Bound Functions and Function Imports in JavaScript</a>
570 * for a complete explanation.
571 *
572 * This extension already exists in some browsers (namely, Firefox 3), but
573 * we provide it to support those that don‘t.
574 *
575 * Parameters:
576 * (Object) obj - The object that will become ‘this‘ in the bound function.
577 * (Object) argN - An option argument that will be prepended to the
578 * arguments given for the function call
579 *
580 * Returns:
581 * The bound function.
582 */
583 if (!Function.prototype.bind) {
584 Function.prototype.bind = function (obj /*, arg1, arg2, ... */)
585 {
586 var func = this;
587 var _slice = Array.prototype.slice;
588 var _concat = Array.prototype.concat;
589 var _args = _slice.call(arguments, 1);
590
591 return function () {
592 return func.apply(obj ? obj : this,
593 _concat.call(_args,
594 _slice.call(arguments, 0)));
595 };
596 };
597 }
598
599 /** PrivateFunction: Array.isArray
600 * This is a polyfill for the ES5 Array.isArray method.
601 */
602 if (!Array.isArray) {
603 Array.isArray = function(arg) {
604 return Object.prototype.toString.call(arg) === ‘[object Array]‘;
605 };
606 }
607
608 /** PrivateFunction: Array.prototype.indexOf
609 * Return the index of an object in an array.
610 *
611 * This function is not supplied by some JavaScript implementations, so
612 * we provide it if it is missing. This code is from:
613 * http://developer.mozilla.org/En/Core_JavaScript_1.5_Reference:Objects:Array:indexOf
614 *
615 * Parameters:
616 * (Object) elt - The object to look for.
617 * (Integer) from - The index from which to start looking. (optional).
618 *
619 * Returns:
620 * The index of elt in the array or -1 if not found.
621 */
622 if (!Array.prototype.indexOf)
623 {
624 Array.prototype.indexOf = function(elt /*, from*/)
625 {
626 var len = this.length;
627
628 var from = Number(arguments[1]) || 0;
629 from = (from < 0) ? Math.ceil(from) : Math.floor(from);
630 if (from < 0) {
631 from += len;
632 }
633
634 for (; from < len; from++) {
635 if (from in this && this[from] === elt) {
636 return from;
637 }
638 }
639
640 return -1;
641 };
642 }
643
644 /*
645 This program is distributed under the terms of the MIT license.
646 Please see the LICENSE file for details.
647
648 Copyright 2006-2008, OGG, LLC
649 */
650
651 /* jshint undef: true, unused: true:, noarg: true, latedef: true */
652 /*global define, document, window, setTimeout, clearTimeout, console, ActiveXObject, DOMParser */
653
654 (function (root, factory) {
655 if (typeof define === ‘function‘ && define.amd) {
656 define(‘strophe-core‘, [
657 ‘strophe-sha1‘,
658 ‘strophe-base64‘,
659 ‘strophe-md5‘,
660 "strophe-polyfill"
661 ], function () {
662 return factory.apply(this, arguments);
663 });
664 } else {
665 // Browser globals
666 var o = factory(root.SHA1, root.Base64, root.MD5);
667 window.Strophe = o.Strophe;
668 window.$build = o.$build;
669 window.$iq = o.$iq;
670 window.$msg = o.$msg;
671 window.$pres = o.$pres;
672 window.SHA1 = o.SHA1;
673 window.Base64 = o.Base64;
674 window.MD5 = o.MD5;
675 window.b64_hmac_sha1 = o.SHA1.b64_hmac_sha1;
676 window.b64_sha1 = o.SHA1.b64_sha1;
677 window.str_hmac_sha1 = o.SHA1.str_hmac_sha1;
678 window.str_sha1 = o.SHA1.str_sha1;
679 }
680 }(this, function (SHA1, Base64, MD5) {
681
682 var Strophe;
683
684 /** Function: $build
685 * Create a Strophe.Builder.
686 * This is an alias for ‘new Strophe.Builder(name, attrs)‘.
687 *
688 * Parameters:
689 * (String) name - The root element name.
690 * (Object) attrs - The attributes for the root element in object notation.
691 *
692 * Returns:
693 * A new Strophe.Builder object.
694 */
695 function $build(name, attrs) { return new Strophe.Builder(name, attrs); }
696
697 /** Function: $msg
698 * Create a Strophe.Builder with a <message/> element as the root.
699 *
700 * Parmaeters:
701 * (Object) attrs - The <message/> element attributes in object notation.
702 *
703 * Returns:
704 * A new Strophe.Builder object.
705 */
706 function $msg(attrs) { return new Strophe.Builder("message", attrs); }
707
708 /** Function: $iq
709 * Create a Strophe.Builder with an <iq/> element as the root.
710 *
711 * Parameters:
712 * (Object) attrs - The <iq/> element attributes in object notation.
713 *
714 * Returns:
715 * A new Strophe.Builder object.
716 */
717 function $iq(attrs) { return new Strophe.Builder("iq", attrs); }
718
719 /** Function: $pres
720 * Create a Strophe.Builder with a <presence/> element as the root.
721 *
722 * Parameters:
723 * (Object) attrs - The <presence/> element attributes in object notation.
724 *
725 * Returns:
726 * A new Strophe.Builder object.
727 */
728 function $pres(attrs) { return new Strophe.Builder("presence", attrs); }
729
730 /** Class: Strophe
731 * An object container for all Strophe library functions.
732 *
733 * This class is just a container for all the objects and constants
734 * used in the library. It is not meant to be instantiated, but to
735 * provide a namespace for library objects, constants, and functions.
736 */
737 Strophe = {
738 /** Constant: VERSION
739 * The version of the Strophe library. Unreleased builds will have
740 * a version of head-HASH where HASH is a partial revision.
741 */
742 VERSION: "1.2.2",
743
744 /** Constants: XMPP Namespace Constants
745 * Common namespace constants from the XMPP RFCs and XEPs.
746 *
747 * NS.HTTPBIND - HTTP BIND namespace from XEP 124.
748 * NS.BOSH - BOSH namespace from XEP 206.
749 * NS.CLIENT - Main XMPP client namespace.
750 * NS.AUTH - Legacy authentication namespace.
751 * NS.ROSTER - Roster operations namespace.
752 * NS.PROFILE - Profile namespace.
753 * NS.DISCO_INFO - Service discovery info namespace from XEP 30.
754 * NS.DISCO_ITEMS - Service discovery items namespace from XEP 30.
755 * NS.MUC - Multi-User Chat namespace from XEP 45.
756 * NS.SASL - XMPP SASL namespace from RFC 3920.
757 * NS.STREAM - XMPP Streams namespace from RFC 3920.
758 * NS.BIND - XMPP Binding namespace from RFC 3920.
759 * NS.SESSION - XMPP Session namespace from RFC 3920.
760 * NS.XHTML_IM - XHTML-IM namespace from XEP 71.
761 * NS.XHTML - XHTML body namespace from XEP 71.
762 */
763 NS: {
764 HTTPBIND: "http://jabber.org/protocol/httpbind",
765 BOSH: "urn:xmpp:xbosh",
766 CLIENT: "jabber:client",
767 AUTH: "jabber:iq:auth",
768 ROSTER: "jabber:iq:roster",
769 PROFILE: "jabber:iq:profile",
770 DISCO_INFO: "http://jabber.org/protocol/disco#info",
771 DISCO_ITEMS: "http://jabber.org/protocol/disco#items",
772 MUC: "http://jabber.org/protocol/muc",
773 SASL: "urn:ietf:params:xml:ns:xmpp-sasl",
774 STREAM: "http://etherx.jabber.org/streams",
775 FRAMING: "urn:ietf:params:xml:ns:xmpp-framing",
776 BIND: "urn:ietf:params:xml:ns:xmpp-bind",
777 SESSION: "urn:ietf:params:xml:ns:xmpp-session",
778 VERSION: "jabber:iq:version",
779 STANZAS: "urn:ietf:params:xml:ns:xmpp-stanzas",
780 XHTML_IM: "http://jabber.org/protocol/xhtml-im",
781 XHTML: "http://www.w3.org/1999/xhtml"
782 },
783
784
785 /** Constants: XHTML_IM Namespace
786 * contains allowed tags, tag attributes, and css properties.
787 * Used in the createHtml function to filter incoming html into the allowed XHTML-IM subset.
788 * See http://xmpp.org/extensions/xep-0071.html#profile-summary for the list of recommended
789 * allowed tags and their attributes.
790 */
791 XHTML: {
792 tags: [‘a‘,‘blockquote‘,‘br‘,‘cite‘,‘em‘,‘img‘,‘li‘,‘ol‘,‘p‘,‘span‘,‘strong‘,‘ul‘,‘body‘],
793 attributes: {
794 ‘a‘: [‘href‘],
795 ‘blockquote‘: [‘style‘],
796 ‘br‘: [],
797 ‘cite‘: [‘style‘],
798 ‘em‘: [],
799 ‘img‘: [‘src‘, ‘alt‘, ‘style‘, ‘height‘, ‘width‘],
800 ‘li‘: [‘style‘],
801 ‘ol‘: [‘style‘],
802 ‘p‘: [‘style‘],
803 ‘span‘: [‘style‘],
804 ‘strong‘: [],
805 ‘ul‘: [‘style‘],
806 ‘body‘: []
807 },
808 css: [‘background-color‘,‘color‘,‘font-family‘,‘font-size‘,‘font-style‘,‘font-weight‘,‘margin-left‘,‘margin-right‘,‘text-align‘,‘text-decoration‘],
809 /** Function: XHTML.validTag
810 *
811 * Utility method to determine whether a tag is allowed
812 * in the XHTML_IM namespace.
813 *
814 * XHTML tag names are case sensitive and must be lower case.
815 */
816 validTag: function(tag) {
817 for (var i = 0; i < Strophe.XHTML.tags.length; i++) {
818 if (tag == Strophe.XHTML.tags[i]) {
819 return true;
820 }
821 }
822 return false;
823 },
824 /** Function: XHTML.validAttribute
825 *
826 * Utility method to determine whether an attribute is allowed
827 * as recommended per XEP-0071
828 *
829 * XHTML attribute names are case sensitive and must be lower case.
830 */
831 validAttribute: function(tag, attribute) {
832 if(typeof Strophe.XHTML.attributes[tag] !== ‘undefined‘ && Strophe.XHTML.attributes[tag].length > 0) {
833 for(var i = 0; i < Strophe.XHTML.attributes[tag].length; i++) {
834 if(attribute == Strophe.XHTML.attributes[tag][i]) {
835 return true;
836 }
837 }
838 }
839 return false;
840 },
841 validCSS: function(style)
842 {
843 for(var i = 0; i < Strophe.XHTML.css.length; i++) {
844 if(style == Strophe.XHTML.css[i]) {
845 return true;
846 }
847 }
848 return false;
849 }
850 },
851
852 /** Constants: Connection Status Constants
853 * Connection status constants for use by the connection handler
854 * callback.
855 *
856 * Status.ERROR - An error has occurred
857 * Status.CONNECTING - The connection is currently being made
858 * Status.CONNFAIL - The connection attempt failed
859 * Status.AUTHENTICATING - The connection is authenticating
860 * Status.AUTHFAIL - The authentication attempt failed
861 * Status.CONNECTED - The connection has succeeded
862 * Status.DISCONNECTED - The connection has been terminated
863 * Status.DISCONNECTING - The connection is currently being terminated
864 * Status.ATTACHED - The connection has been attached
865 */
866 Status: {
867 ERROR: 0,
868 CONNECTING: 1,
869 CONNFAIL: 2,
870 AUTHENTICATING: 3,
871 AUTHFAIL: 4,
872 CONNECTED: 5,
873 DISCONNECTED: 6,
874 DISCONNECTING: 7,
875 ATTACHED: 8,
876 REDIRECT: 9
877 },
878
879 /** Constants: Log Level Constants
880 * Logging level indicators.
881 *
882 * LogLevel.DEBUG - Debug output
883 * LogLevel.INFO - Informational output
884 * LogLevel.WARN - Warnings
885 * LogLevel.ERROR - Errors
886 * LogLevel.FATAL - Fatal errors
887 */
888 LogLevel: {
889 DEBUG: 0,
890 INFO: 1,
891 WARN: 2,
892 ERROR: 3,
893 FATAL: 4
894 },
895
896 /** PrivateConstants: DOM Element Type Constants
897 * DOM element types.
898 *
899 * ElementType.NORMAL - Normal element.
900 * ElementType.TEXT - Text data element.
901 * ElementType.FRAGMENT - XHTML fragment element.
902 */
903 ElementType: {
904 NORMAL: 1,
905 TEXT: 3,
906 CDATA: 4,
907 FRAGMENT: 11
908 },
909
910 /** PrivateConstants: Timeout Values
911 * Timeout values for error states. These values are in seconds.
912 * These should not be changed unless you know exactly what you are
913 * doing.
914 *
915 * TIMEOUT - Timeout multiplier. A waiting request will be considered
916 * failed after Math.floor(TIMEOUT * wait) seconds have elapsed.
917 * This defaults to 1.1, and with default wait, 66 seconds.
918 * SECONDARY_TIMEOUT - Secondary timeout multiplier. In cases where
919 * Strophe can detect early failure, it will consider the request
920 * failed if it doesn‘t return after
921 * Math.floor(SECONDARY_TIMEOUT * wait) seconds have elapsed.
922 * This defaults to 0.1, and with default wait, 6 seconds.
923 */
924 TIMEOUT: 1.1,
925 SECONDARY_TIMEOUT: 0.1,
926
927 /** Function: addNamespace
928 * This function is used to extend the current namespaces in
929 * Strophe.NS. It takes a key and a value with the key being the
930 * name of the new namespace, with its actual value.
931 * For example:
932 * Strophe.addNamespace(‘PUBSUB‘, "http://jabber.org/protocol/pubsub");
933 *
934 * Parameters:
935 * (String) name - The name under which the namespace will be
936 * referenced under Strophe.NS
937 * (String) value - The actual namespace.
938 */
939 addNamespace: function (name, value)
940 {
941 Strophe.NS[name] = value;
942 },
943
944 /** Function: forEachChild
945 * Map a function over some or all child elements of a given element.
946 *
947 * This is a small convenience function for mapping a function over
948 * some or all of the children of an element. If elemName is null, all
949 * children will be passed to the function, otherwise only children
950 * whose tag names match elemName will be passed.
951 *
952 * Parameters:
953 * (XMLElement) elem - The element to operate on.
954 * (String) elemName - The child element tag name filter.
955 * (Function) func - The function to apply to each child. This
956 * function should take a single argument, a DOM element.
957 */
958 forEachChild: function (elem, elemName, func)
959 {
960 var i, childNode;
961
962 for (i = 0; i < elem.childNodes.length; i++) {
963 childNode = elem.childNodes[i];
964 if (childNode.nodeType == Strophe.ElementType.NORMAL &&
965 (!elemName || this.isTagEqual(childNode, elemName))) {
966 func(childNode);
967 }
968 }
969 },
970
971 /** Function: isTagEqual
972 * Compare an element‘s tag name with a string.
973 *
974 * This function is case sensitive.
975 *
976 * Parameters:
977 * (XMLElement) el - A DOM element.
978 * (String) name - The element name.
979 *
980 * Returns:
981 * true if the element‘s tag name matches _el_, and false
982 * otherwise.
983 */
984 isTagEqual: function (el, name)
985 {
986 return el.tagName == name;
987 },
988
989 /** PrivateVariable: _xmlGenerator
990 * _Private_ variable that caches a DOM document to
991 * generate elements.
992 */
993 _xmlGenerator: null,
994
995 /** PrivateFunction: _makeGenerator
996 * _Private_ function that creates a dummy XML DOM document to serve as
997 * an element and text node generator.
998 */
999 _makeGenerator: function () {
1000 var doc;
1001
1002 // IE9 does implement createDocument(); however, using it will cause the browser to leak memory on page unload.
1003 // Here, we test for presence of createDocument() plus IE‘s proprietary documentMode attribute, which would be
1004 // less than 10 in the case of IE9 and below.
1005 if (document.implementation.createDocument === undefined ||
1006 document.implementation.createDocument && document.documentMode && document.documentMode < 10) {
1007 doc = this._getIEXmlDom();
1008 doc.appendChild(doc.createElement(‘strophe‘));
1009 } else {
1010 doc = document.implementation
1011 .createDocument(‘jabber:client‘, ‘strophe‘, null);
1012 }
1013
1014 return doc;
1015 },
1016
1017 /** Function: xmlGenerator
1018 * Get the DOM document to generate elements.
1019 *
1020 * Returns:
1021 * The currently used DOM document.
1022 */
1023 xmlGenerator: function () {
1024 if (!Strophe._xmlGenerator) {
1025 Strophe._xmlGenerator = Strophe._makeGenerator();
1026 }
1027 return Strophe._xmlGenerator;
1028 },
1029
1030 /** PrivateFunction: _getIEXmlDom
1031 * Gets IE xml doc object
1032 *
1033 * Returns:
1034 * A Microsoft XML DOM Object
1035 * See Also:
1036 * http://msdn.microsoft.com/en-us/library/ms757837%28VS.85%29.aspx
1037 */
1038 _getIEXmlDom : function() {
1039 var doc = null;
1040 var docStrings = [
1041 "Msxml2.DOMDocument.6.0",
1042 "Msxml2.DOMDocument.5.0",
1043 "Msxml2.DOMDocument.4.0",
1044 "MSXML2.DOMDocument.3.0",
1045 "MSXML2.DOMDocument",
1046 "MSXML.DOMDocument",
1047 "Microsoft.XMLDOM"
1048 ];
1049
1050 for (var d = 0; d < docStrings.length; d++) {
1051 if (doc === null) {
1052 try {
1053 doc = new ActiveXObject(docStrings[d]);
1054 } catch (e) {
1055 doc = null;
1056 }
1057 } else {
1058 break;
1059 }
1060 }
1061
1062 return doc;
1063 },
1064
1065 /** Function: xmlElement
1066 * Create an XML DOM element.
1067 *
1068 * This function creates an XML DOM element correctly across all
1069 * implementations. Note that these are not HTML DOM elements, which
1070 * aren‘t appropriate for XMPP stanzas.
1071 *
1072 * Parameters:
1073 * (String) name - The name for the element.
1074 * (Array|Object) attrs - An optional array or object containing
1075 * key/value pairs to use as element attributes. The object should
1076 * be in the format {‘key‘: ‘value‘} or {key: ‘value‘}. The array
1077 * should have the format [[‘key1‘, ‘value1‘], [‘key2‘, ‘value2‘]].
1078 * (String) text - The text child data for the element.
1079 *
1080 * Returns:
1081 * A new XML DOM element.
1082 */
1083 xmlElement: function (name)
1084 {
1085 if (!name) { return null; }
1086
1087 var node = Strophe.xmlGenerator().createElement(name);
1088
1089 // FIXME: this should throw errors if args are the wrong type or
1090 // there are more than two optional args
1091 var a, i, k;
1092 for (a = 1; a < arguments.length; a++) {
1093 var arg = arguments[a];
1094 if (!arg) { continue; }
1095 if (typeof(arg) == "string" ||
1096 typeof(arg) == "number") {
1097 node.appendChild(Strophe.xmlTextNode(arg));
1098 } else if (typeof(arg) == "object" &&
1099 typeof(arg.sort) == "function") {
1100 for (i = 0; i < arg.length; i++) {
1101 var attr = arg[i];
1102 if (typeof(attr) == "object" &&
1103 typeof(attr.sort) == "function" &&
1104 attr[1] !== undefined) {
1105 node.setAttribute(attr[0], attr[1]);
1106 }
1107 }
1108 } else if (typeof(arg) == "object") {
1109 for (k in arg) {
1110 if (arg.hasOwnProperty(k)) {
1111 if (arg[k] !== undefined) {
1112 node.setAttribute(k, arg[k]);
1113 }
1114 }
1115 }
1116 }
1117 }
1118
1119 return node;
1120 },
1121
1122 /* Function: xmlescape
1123 * Excapes invalid xml characters.
1124 *
1125 * Parameters:
1126 * (String) text - text to escape.
1127 *
1128 * Returns:
1129 * Escaped text.
1130 */
1131 xmlescape: function(text)
1132 {
1133 text = text.replace(/\&/g, "&");
1134 text = text.replace(/</g, "<");
1135 text = text.replace(/>/g, ">");
1136 text = text.replace(/‘/g, "'");
1137 text = text.replace(/"/g, """);
1138 return text;
1139 },
1140
1141 /* Function: xmlunescape
1142 * Unexcapes invalid xml characters.
1143 *
1144 * Parameters:
1145 * (String) text - text to unescape.
1146 *
1147 * Returns:
1148 * Unescaped text.
1149 */
1150 xmlunescape: function(text)
1151 {
1152 text = text.replace(/\&/g, "&");
1153 text = text.replace(/</g, "<");
1154 text = text.replace(/>/g, ">");
1155 text = text.replace(/'/g, "‘");
1156 text = text.replace(/"/g, "\"");
1157 return text;
1158 },
1159
1160 /** Function: xmlTextNode
1161 * Creates an XML DOM text node.
1162 *
1163 * Provides a cross implementation version of document.createTextNode.
1164 *
1165 * Parameters:
1166 * (String) text - The content of the text node.
1167 *
1168 * Returns:
1169 * A new XML DOM text node.
1170 */
1171 xmlTextNode: function (text)
1172 {
1173 return Strophe.xmlGenerator().createTextNode(text);
1174 },
1175
1176 /** Function: xmlHtmlNode
1177 * Creates an XML DOM html node.
1178 *
1179 * Parameters:
1180 * (String) html - The content of the html node.
1181 *
1182 * Returns:
1183 * A new XML DOM text node.
1184 */
1185 xmlHtmlNode: function (html)
1186 {
1187 var node;
1188 //ensure text is escaped
1189 if (window.DOMParser) {
1190 var parser = new DOMParser();
1191 node = parser.parseFromString(html, "text/xml");
1192 } else {
1193 node = new ActiveXObject("Microsoft.XMLDOM");
1194 node.async="false";
1195 node.loadXML(html);
1196 }
1197 return node;
1198 },
1199
1200 /** Function: getText
1201 * Get the concatenation of all text children of an element.
1202 *
1203 * Parameters:
1204 * (XMLElement) elem - A DOM element.
1205 *
1206 * Returns:
1207 * A String with the concatenated text of all text element children.
1208 */
1209 getText: function (elem)
1210 {
1211 if (!elem) { return null; }
1212
1213 var str = "";
1214 if (elem.childNodes.length === 0 && elem.nodeType ==
1215 Strophe.ElementType.TEXT) {
1216 str += elem.nodeValue;
1217 }
1218
1219 for (var i = 0; i < elem.childNodes.length; i++) {
1220 if (elem.childNodes[i].nodeType == Strophe.ElementType.TEXT) {
1221 str += elem.childNodes[i].nodeValue;
1222 }
1223 }
1224
1225 return Strophe.xmlescape(str);
1226 },
1227
1228 /** Function: copyElement
1229 * Copy an XML DOM element.
1230 *
1231 * This function copies a DOM element and all its descendants and returns
1232 * the new copy.
1233 *
1234 * Parameters:
1235 * (XMLElement) elem - A DOM element.
1236 *
1237 * Returns:
1238 * A new, copied DOM element tree.
1239 */
1240 copyElement: function (elem)
1241 {
1242 var i, el;
1243 if (elem.nodeType == Strophe.ElementType.NORMAL) {
1244 el = Strophe.xmlElement(elem.tagName);
1245
1246 for (i = 0; i < elem.attributes.length; i++) {
1247 el.setAttribute(elem.attributes[i].nodeName,
1248 elem.attributes[i].value);
1249 }
1250
1251 for (i = 0; i < elem.childNodes.length; i++) {
1252 el.appendChild(Strophe.copyElement(elem.childNodes[i]));
1253 }
1254 } else if (elem.nodeType == Strophe.ElementType.TEXT) {
1255 el = Strophe.xmlGenerator().createTextNode(elem.nodeValue);
1256 }
1257
1258 return el;
1259 },
1260
1261
1262 /** Function: createHtml
1263 * Copy an HTML DOM element into an XML DOM.
1264 *
1265 * This function copies a DOM element and all its descendants and returns
1266 * the new copy.
1267 *
1268 * Parameters:
1269 * (HTMLElement) elem - A DOM element.
1270 *
1271 * Returns:
1272 * A new, copied DOM element tree.
1273 */
1274 createHtml: function (elem)
1275 {
1276 var i, el, j, tag, attribute, value, css, cssAttrs, attr, cssName, cssValue;
1277 if (elem.nodeType == Strophe.ElementType.NORMAL) {
1278 tag = elem.nodeName.toLowerCase(); // XHTML tags must be lower case.
1279 if(Strophe.XHTML.validTag(tag)) {
1280 try {
1281 el = Strophe.xmlElement(tag);
1282 for(i = 0; i < Strophe.XHTML.attributes[tag].length; i++) {
1283 attribute = Strophe.XHTML.attributes[tag][i];
1284 value = elem.getAttribute(attribute);
1285 if(typeof value == ‘undefined‘ || value === null || value === ‘‘ || value === false || value === 0) {
1286 continue;
1287 }
1288 if(attribute == ‘style‘ && typeof value == ‘object‘) {
1289 if(typeof value.cssText != ‘undefined‘) {
1290 value = value.cssText; // we‘re dealing with IE, need to get CSS out
1291 }
1292 }
1293 // filter out invalid css styles
1294 if(attribute == ‘style‘) {
1295 css = [];
1296 cssAttrs = value.split(‘;‘);
1297 for(j = 0; j < cssAttrs.length; j++) {
1298 attr = cssAttrs[j].split(‘:‘);
1299 cssName = attr[0].replace(/^\s*/, "").replace(/\s*$/, "").toLowerCase();
1300 if(Strophe.XHTML.validCSS(cssName)) {
1301 cssValue = attr[1].replace(/^\s*/, "").replace(/\s*$/, "");
1302 css.push(cssName + ‘: ‘ + cssValue);
1303 }
1304 }
1305 if(css.length > 0) {
1306 value = css.join(‘; ‘);
1307 el.setAttribute(attribute, value);
1308 }
1309 } else {
1310 el.setAttribute(attribute, value);
1311 }
1312 }
1313
1314 for (i = 0; i < elem.childNodes.length; i++) {
1315 el.appendChild(Strophe.createHtml(elem.childNodes[i]));
1316 }
1317 } catch(e) { // invalid elements
1318 el = Strophe.xmlTextNode(‘‘);
1319 }
1320 } else {
1321 el = Strophe.xmlGenerator().createDocumentFragment();
1322 for (i = 0; i < elem.childNodes.length; i++) {
1323 el.appendChild(Strophe.createHtml(elem.childNodes[i]));
1324 }
1325 }
1326 } else if (elem.nodeType == Strophe.ElementType.FRAGMENT) {
1327 el = Strophe.xmlGenerator().createDocumentFragment();
1328 for (i = 0; i < elem.childNodes.length; i++) {
1329 el.appendChild(Strophe.createHtml(elem.childNodes[i]));
1330 }
1331 } else if (elem.nodeType == Strophe.ElementType.TEXT) {
1332 el = Strophe.xmlTextNode(elem.nodeValue);
1333 }
1334
1335 return el;
1336 },
1337
1338 /** Function: escapeNode
1339 * Escape the node part (also called local part) of a JID.
1340 *
1341 * Parameters:
1342 * (String) node - A node (or local part).
1343 *
1344 * Returns:
1345 * An escaped node (or local part).
1346 */
1347 escapeNode: function (node)
1348 {
1349 if (typeof node !== "string") { return node; }
1350 return node.replace(/^\s+|\s+$/g, ‘‘)
1351 .replace(/\\/g, "\\5c")
1352 .replace(/ /g, "\\20")
1353 .replace(/\"/g, "\\22")
1354 .replace(/\&/g, "\\26")
1355 .replace(/\‘/g, "\\27")
1356 .replace(/\//g, "\\2f")
1357 .replace(/:/g, "\\3a")
1358 .replace(/</g, "\\3c")
1359 .replace(/>/g, "\\3e")
1360 .replace(/@/g, "\\40");
1361 },
1362
1363 /** Function: unescapeNode
1364 * Unescape a node part (also called local part) of a JID.
1365 *
1366 * Parameters:
1367 * (String) node - A node (or local part).
1368 *
1369 * Returns:
1370 * An unescaped node (or local part).
1371 */
1372 unescapeNode: function (node)
1373 {
1374 if (typeof node !== "string") { return node; }
1375 return node.replace(/\\20/g, " ")
1376 .replace(/\\22/g, ‘"‘)
1377 .replace(/\\26/g, "&")
1378 .replace(/\\27/g, "‘")
1379 .replace(/\\2f/g, "/")
1380 .replace(/\\3a/g, ":")
1381 .replace(/\\3c/g, "<")
1382 .replace(/\\3e/g, ">")
1383 .replace(/\\40/g, "@")
1384 .replace(/\\5c/g, "\\");
1385 },
1386
1387 /** Function: getNodeFromJid
1388 * Get the node portion of a JID String.
1389 *
1390 * Parameters:
1391 * (String) jid - A JID.
1392 *
1393 * Returns:
1394 * A String containing the node.
1395 */
1396 getNodeFromJid: function (jid)
1397 {
1398 if (jid.indexOf("@") < 0) { return null; }
1399 return jid.split("@")[0];
1400 },
1401
1402 /** Function: getDomainFromJid
1403 * Get the domain portion of a JID String.
1404 *
1405 * Parameters:
1406 * (String) jid - A JID.
1407 *
1408 * Returns:
1409 * A String containing the domain.
1410 */
1411 getDomainFromJid: function (jid)
1412 {
1413 var bare = Strophe.getBareJidFromJid(jid);
1414 if (bare.indexOf("@") < 0) {
1415 return bare;
1416 } else {
1417 var parts = bare.split("@");
1418 parts.splice(0, 1);
1419 return parts.join(‘@‘);
1420 }
1421 },
1422
1423 /** Function: getResourceFromJid
1424 * Get the resource portion of a JID String.
1425 *
1426 * Parameters:
1427 * (String) jid - A JID.
1428 *
1429 * Returns:
1430 * A String containing the resource.
1431 */
1432 getResourceFromJid: function (jid)
1433 {
1434 var s = jid.split("/");
1435 if (s.length < 2) { return null; }
1436 s.splice(0, 1);
1437 return s.join(‘/‘);
1438 },
1439
1440 /** Function: getBareJidFromJid
1441 * Get the bare JID from a JID String.
1442 *
1443 * Parameters:
1444 * (String) jid - A JID.
1445 *
1446 * Returns:
1447 * A String containing the bare JID.
1448 */
1449 getBareJidFromJid: function (jid)
1450 {
1451 return jid ? jid.split("/")[0] : null;
1452 },
1453
1454 /** Function: log
1455 * User overrideable logging function.
1456 *
1457 * This function is called whenever the Strophe library calls any
1458 * of the logging functions. The default implementation of this
1459 * function does nothing. If client code wishes to handle the logging
1460 * messages, it should override this with
1461 * > Strophe.log = function (level, msg) {
1462 * > (user code here)
1463 * > };
1464 *
1465 * Please note that data sent and received over the wire is logged
1466 * via Strophe.Connection.rawInput() and Strophe.Connection.rawOutput().
1467 *
1468 * The different levels and their meanings are
1469 *
1470 * DEBUG - Messages useful for debugging purposes.
1471 * INFO - Informational messages. This is mostly information like
1472 * ‘disconnect was called‘ or ‘SASL auth succeeded‘.
1473 * WARN - Warnings about potential problems. This is mostly used
1474 * to report transient connection errors like request timeouts.
1475 * ERROR - Some error occurred.
1476 * FATAL - A non-recoverable fatal error occurred.
1477 *
1478 * Parameters:
1479 * (Integer) level - The log level of the log message. This will
1480 * be one of the values in Strophe.LogLevel.
1481 * (String) msg - The log message.
1482 */
1483 /* jshint ignore:start */
1484 log: function (level, msg)
1485 {
1486 return;
1487 },
1488 /* jshint ignore:end */
1489
1490 /** Function: debug
1491 * Log a message at the Strophe.LogLevel.DEBUG level.
1492 *
1493 * Parameters:
1494 * (String) msg - The log message.
1495 */
1496 debug: function(msg)
1497 {
1498 this.log(this.LogLevel.DEBUG, msg);
1499 },
1500
1501 /** Function: info
1502 * Log a message at the Strophe.LogLevel.INFO level.
1503 *
1504 * Parameters:
1505 * (String) msg - The log message.
1506 */
1507 info: function (msg)
1508 {
1509 this.log(this.LogLevel.INFO, msg);
1510 },
1511
1512 /** Function: warn
1513 * Log a message at the Strophe.LogLevel.WARN level.
1514 *
1515 * Parameters:
1516 * (String) msg - The log message.
1517 */
1518 warn: function (msg)
1519 {
1520 this.log(this.LogLevel.WARN, msg);
1521 },
1522
1523 /** Function: error
1524 * Log a message at the Strophe.LogLevel.ERROR level.
1525 *
1526 * Parameters:
1527 * (String) msg - The log message.
1528 */
1529 error: function (msg)
1530 {
1531 this.log(this.LogLevel.ERROR, msg);
1532 },
1533
1534 /** Function: fatal
1535 * Log a message at the Strophe.LogLevel.FATAL level.
1536 *
1537 * Parameters:
1538 * (String) msg - The log message.
1539 */
1540 fatal: function (msg)
1541 {
1542 this.log(this.LogLevel.FATAL, msg);
1543 },
1544
1545 /** Function: serialize
1546 * Render a DOM element and all descendants to a String.
1547 *
1548 * Parameters:
1549 * (XMLElement) elem - A DOM element.
1550 *
1551 * Returns:
1552 * The serialized element tree as a String.
1553 */
1554 serialize: function (elem)
1555 {
1556 var result;
1557
1558 if (!elem) { return null; }
1559
1560 if (typeof(elem.tree) === "function") {
1561 elem = elem.tree();
1562 }
1563
1564 var nodeName = elem.nodeName;
1565 var i, child;
1566
1567 if (elem.getAttribute("_realname")) {
1568 nodeName = elem.getAttribute("_realname");
1569 }
1570
1571 result = "<" + nodeName;
1572 for (i = 0; i < elem.attributes.length; i++) {
1573 if(elem.attributes[i].nodeName != "_realname") {
1574 result += " " + elem.attributes[i].nodeName +
1575 "=‘" + elem.attributes[i].value
1576 .replace(/&/g, "&")
1577 .replace(/\‘/g, "'")
1578 .replace(/>/g, ">")
1579 .replace(/</g, "<") + "‘";
1580 }
1581 }
1582
1583 if (elem.childNodes.length > 0) {
1584 result += ">";
1585 for (i = 0; i < elem.childNodes.length; i++) {
1586 child = elem.childNodes[i];
1587 switch( child.nodeType ){
1588 case Strophe.ElementType.NORMAL:
1589 // normal element, so recurse
1590 result += Strophe.serialize(child);
1591 break;
1592 case Strophe.ElementType.TEXT:
1593 // text element to escape values
1594 result += Strophe.xmlescape(child.nodeValue);
1595 break;
1596 case Strophe.ElementType.CDATA:
1597 // cdata section so don‘t escape values
1598 result += "<![CDATA["+child.nodeValue+"]]>";
1599 }
1600 }
1601 result += "</" + nodeName + ">";
1602 } else {
1603 result += "/>";
1604 }
1605
1606 return result;
1607 },
1608
1609 /** PrivateVariable: _requestId
1610 * _Private_ variable that keeps track of the request ids for
1611 * connections.
1612 */
1613 _requestId: 0,
1614
1615 /** PrivateVariable: Strophe.connectionPlugins
1616 * _Private_ variable Used to store plugin names that need
1617 * initialization on Strophe.Connection construction.
1618 */
1619 _connectionPlugins: {},
1620
1621 /** Function: addConnectionPlugin
1622 * Extends the Strophe.Connection object with the given plugin.
1623 *
1624 * Parameters:
1625 * (String) name - The name of the extension.
1626 * (Object) ptype - The plugin‘s prototype.
1627 */
1628 addConnectionPlugin: function (name, ptype)
1629 {
1630 Strophe._connectionPlugins[name] = ptype;
1631 }
1632 };
1633
1634 /** Class: Strophe.Builder
1635 * XML DOM builder.
1636 *
1637 * This object provides an interface similar to JQuery but for building
1638 * DOM element easily and rapidly. All the functions except for toString()
1639 * and tree() return the object, so calls can be chained. Here‘s an
1640 * example using the $iq() builder helper.
1641 * > $iq({to: ‘you‘, from: ‘me‘, type: ‘get‘, id: ‘1‘})
1642 * > .c(‘query‘, {xmlns: ‘strophe:example‘})
1643 * > .c(‘example‘)
1644 * > .toString()
1645 * The above generates this XML fragment
1646 * > <iq to=‘you‘ from=‘me‘ type=‘get‘ id=‘1‘>
1647 * > <query xmlns=‘strophe:example‘>
1648 * > <example/>
1649 * > </query>
1650 * > </iq>
1651 * The corresponding DOM manipulations to get a similar fragment would be
1652 * a lot more tedious and probably involve several helper variables.
1653 *
1654 * Since adding children makes new operations operate on the child, up()
1655 * is provided to traverse up the tree. To add two children, do
1656 * > builder.c(‘child1‘, ...).up().c(‘child2‘, ...)
1657 * The next operation on the Builder will be relative to the second child.
1658 */
1659
1660 /** Constructor: Strophe.Builder
1661 * Create a Strophe.Builder object.
1662 *
1663 * The attributes should be passed in object notation. For example
1664 * > var b = new Builder(‘message‘, {to: ‘you‘, from: ‘me‘});
1665 * or
1666 * > var b = new Builder(‘messsage‘, {‘xml:lang‘: ‘en‘});
1667 *
1668 * Parameters:
1669 * (String) name - The name of the root element.
1670 * (Object) attrs - The attributes for the root element in object notation.
1671 *
1672 * Returns:
1673 * A new Strophe.Builder.
1674 */
1675 Strophe.Builder = function (name, attrs)
1676 {
1677 // Set correct namespace for jabber:client elements
1678 if (name == "presence" || name == "message" || name == "iq") {
1679 if (attrs && !attrs.xmlns) {
1680 attrs.xmlns = Strophe.NS.CLIENT;
1681 } else if (!attrs) {
1682 attrs = {xmlns: Strophe.NS.CLIENT};
1683 }
1684 }
1685
1686 // Holds the tree being built.
1687 this.nodeTree = Strophe.xmlElement(name, attrs);
1688
1689 // Points to the current operation node.
1690 this.node = this.nodeTree;
1691 };
1692
1693 Strophe.Builder.prototype = {
1694 /** Function: tree
1695 * Return the DOM tree.
1696 *
1697 * This function returns the current DOM tree as an element object. This
1698 * is suitable for passing to functions like Strophe.Connection.send().
1699 *
1700 * Returns:
1701 * The DOM tree as a element object.
1702 */
1703 tree: function ()
1704 {
1705 return this.nodeTree;
1706 },
1707
1708 /** Function: toString
1709 * Serialize the DOM tree to a String.
1710 *
1711 * This function returns a string serialization of the current DOM
1712 * tree. It is often used internally to pass data to a
1713 * Strophe.Request object.
1714 *
1715 * Returns:
1716 * The serialized DOM tree in a String.
1717 */
1718 toString: function ()
1719 {
1720 return Strophe.serialize(this.nodeTree);
1721 },
1722
1723 /** Function: up
1724 * Make the current parent element the new current element.
1725 *
1726 * This function is often used after c() to traverse back up the tree.
1727 * For example, to add two children to the same element
1728 * > builder.c(‘child1‘, {}).up().c(‘child2‘, {});
1729 *
1730 * Returns:
1731 * The Stophe.Builder object.
1732 */
1733 up: function ()
1734 {
1735 this.node = this.node.parentNode;
1736 return this;
1737 },
1738
1739 /** Function: attrs
1740 * Add or modify attributes of the current element.
1741 *
1742 * The attributes should be passed in object notation. This function
1743 * does not move the current element pointer.
1744 *
1745 * Parameters:
1746 * (Object) moreattrs - The attributes to add/modify in object notation.
1747 *
1748 * Returns:
1749 * The Strophe.Builder object.
1750 */
1751 attrs: function (moreattrs)
1752 {
1753 for (var k in moreattrs) {
1754 if (moreattrs.hasOwnProperty(k)) {
1755 if (moreattrs[k] === undefined) {
1756 this.node.removeAttribute(k);
1757 } else {
1758 this.node.setAttribute(k, moreattrs[k]);
1759 }
1760 }
1761 }
1762 return this;
1763 },
1764
1765 /** Function: c
1766 * Add a child to the current element and make it the new current
1767 * element.
1768 *
1769 * This function moves the current element pointer to the child,
1770 * unless text is provided. If you need to add another child, it
1771 * is necessary to use up() to go back to the parent in the tree.
1772 *
1773 * Parameters:
1774 * (String) name - The name of the child.
1775 * (Object) attrs - The attributes of the child in object notation.
1776 * (String) text - The text to add to the child.
1777 *
1778 * Returns:
1779 * The Strophe.Builder object.
1780 */
1781 c: function (name, attrs, text)
1782 {
1783 var child = Strophe.xmlElement(name, attrs, text);
1784 this.node.appendChild(child);
1785 if (typeof text !== "string") {
1786 this.node = child;
1787 }
1788 return this;
1789 },
1790
1791 /** Function: cnode
1792 * Add a child to the current element and make it the new current
1793 * element.
1794 *
1795 * This function is the same as c() except that instead of using a
1796 * name and an attributes object to create the child it uses an
1797 * existing DOM element object.
1798 *
1799 * Parameters:
1800 * (XMLElement) elem - A DOM element.
1801 *
1802 * Returns:
1803 * The Strophe.Builder object.
1804 */
1805 cnode: function (elem)
1806 {
1807 var impNode;
1808 var xmlGen = Strophe.xmlGenerator();
1809 try {
1810 impNode = (xmlGen.importNode !== undefined);
1811 }
1812 catch (e) {
1813 impNode = false;
1814 }
1815 var newElem = impNode ?
1816 xmlGen.importNode(elem, true) :
1817 Strophe.copyElement(elem);
1818 this.node.appendChild(newElem);
1819 this.node = newElem;
1820 return this;
1821 },
1822
1823 /** Function: t
1824 * Add a child text element.
1825 *
1826 * This *does not* make the child the new current element since there
1827 * are no children of text elements.
1828 *
1829 * Parameters:
1830 * (String) text - The text data to append to the current element.
1831 *
1832 * Returns:
1833 * The Strophe.Builder object.
1834 */
1835 t: function (text)
1836 {
1837 //text=CHEncode(text);
1838 var child = Strophe.xmlTextNode(text);
1839 this.node.appendChild(child);
1840 return this;
1841 },
1842
1843 cht: function (text)
1844 {
1845 text=Base64.chencode(text);
1846 var child = Strophe.xmlTextNode(text);
1847 this.node.appendChild(child);
1848 return this;
1849 },
1850
1851 /** Function: h
1852 * Replace current element contents with the HTML passed in.
1853 *
1854 * This *does not* make the child the new current element
1855 *
1856 * Parameters:
1857 * (String) html - The html to insert as contents of current element.
1858 *
1859 * Returns:
1860 * The Strophe.Builder object.
1861 */
1862 h: function (html)
1863 {
1864 var fragment = document.createElement(‘body‘);
1865
1866 // force the browser to try and fix any invalid HTML tags
1867 fragment.innerHTML = html;
1868
1869 // copy cleaned html into an xml dom
1870 var xhtml = Strophe.createHtml(fragment);
1871
1872 while(xhtml.childNodes.length > 0) {
1873 this.node.appendChild(xhtml.childNodes[0]);
1874 }
1875 return this;
1876 }
1877 };
1878
1879 /** PrivateClass: Strophe.Handler
1880 * _Private_ helper class for managing stanza handlers.
1881 *
1882 * A Strophe.Handler encapsulates a user provided callback function to be
1883 * executed when matching stanzas are received by the connection.
1884 * Handlers can be either one-off or persistant depending on their
1885 * return value. Returning true will cause a Handler to remain active, and
1886 * returning false will remove the Handler.
1887 *
1888 * Users will not use Strophe.Handler objects directly, but instead they
1889 * will use Strophe.Connection.addHandler() and
1890 * Strophe.Connection.deleteHandler().
1891 */
1892
1893 /** PrivateConstructor: Strophe.Handler
1894 * Create and initialize a new Strophe.Handler.
1895 *
1896 * Parameters:
1897 * (Function) handler - A function to be executed when the handler is run.
1898 * (String) ns - The namespace to match.
1899 * (String) name - The element name to match.
1900 * (String) type - The element type to match.
1901 * (String) id - The element id attribute to match.
1902 * (String) from - The element from attribute to match.
1903 * (Object) options - Handler options
1904 *
1905 * Returns:
1906 * A new Strophe.Handler object.
1907 */
1908 Strophe.Handler = function (handler, ns, name, type, id, from, options)
1909 {
1910 this.handler = handler;
1911 this.ns = ns;
1912 this.name = name;
1913 this.type = type;
1914 this.id = id;
1915 this.options = options || {matchBare: false};
1916
1917 // default matchBare to false if undefined
1918 if (!this.options.matchBare) {
1919 this.options.matchBare = false;
1920 }
1921
1922 if (this.options.matchBare) {
1923 this.from = from ? Strophe.getBareJidFromJid(from) : null;
1924 } else {
1925 this.from = from;
1926 }
1927
1928 // whether the handler is a user handler or a system handler
1929 this.user = true;
1930 };
1931
1932 Strophe.Handler.prototype = {
1933 /** PrivateFunction: isMatch
1934 * Tests if a stanza matches the Strophe.Handler.
1935 *
1936 * Parameters:
1937 * (XMLElement) elem - The XML element to test.
1938 *
1939 * Returns:
1940 * true if the stanza matches and false otherwise.
1941 */
1942 isMatch: function (elem)
1943 {
1944 var nsMatch;
1945 var from = null;
1946
1947 if (this.options.matchBare) {
1948 from = Strophe.getBareJidFromJid(elem.getAttribute(‘from‘));
1949 } else {
1950 from = elem.getAttribute(‘from‘);
1951 }
1952
1953 nsMatch = false;
1954 if (!this.ns) {
1955 nsMatch = true;
1956 } else {
1957 var that = this;
1958 Strophe.forEachChild(elem, null, function (elem) {
1959 if (elem.getAttribute("xmlns") == that.ns) {
1960 nsMatch = true;
1961 }
1962 });
1963
1964 nsMatch = nsMatch || elem.getAttribute("xmlns") == this.ns;
1965 }
1966
1967 var elem_type = elem.getAttribute("type");
1968 if (nsMatch &&
1969 (!this.name || Strophe.isTagEqual(elem, this.name)) &&
1970 (!this.type || (Array.isArray(this.type) ? this.type.indexOf(elem_type) != -1 : elem_type == this.type)) &&
1971 (!this.id || elem.getAttribute("id") == this.id) &&
1972 (!this.from || from == this.from)) {
1973 return true;
1974 }
1975
1976 return false;
1977 },
1978
1979 /** PrivateFunction: run
1980 * Run the callback on a matching stanza.
1981 *
1982 * Parameters:
1983 * (XMLElement) elem - The DOM element that triggered the
1984 * Strophe.Handler.
1985 *
1986 * Returns:
1987 * A boolean indicating if the handler should remain active.
1988 */
1989 run: function (elem)
1990 {
1991 var result = null;
1992 try {
1993 result = this.handler(elem);
1994 } catch (e) {
1995 if (e.sourceURL) {
1996 Strophe.fatal("error: " + this.handler +
1997 " " + e.sourceURL + ":" +
1998 e.line + " - " + e.name + ": " + e.message);
1999 } else if (e.fileName) {
2000 if (typeof(console) != "undefined") {
2001 console.trace();
2002 console.error(this.handler, " - error - ", e, e.message);
2003 }
2004 Strophe.fatal("error: " + this.handler + " " +
2005 e.fileName + ":" + e.lineNumber + " - " +
2006 e.name + ": " + e.message);
2007 } else {
2008 Strophe.fatal("error: " + e.message + "\n" + e.stack);
2009 }
2010
2011 throw e;
2012 }
2013
2014 return result;
2015 },
2016
2017 /** PrivateFunction: toString
2018 * Get a String representation of the Strophe.Handler object.
2019 *
2020 * Returns:
2021 * A String.
2022 */
2023 toString: function ()
2024 {
2025 return "{Handler: " + this.handler + "(" + this.name + "," +
2026 this.id + "," + this.ns + ")}";
2027 }
2028 };
2029
2030 /** PrivateClass: Strophe.TimedHandler
2031 * _Private_ helper class for managing timed handlers.
2032 *
2033 * A Strophe.TimedHandler encapsulates a user provided callback that
2034 * should be called after a certain period of time or at regular
2035 * intervals. The return value of the callback determines whether the
2036 * Strophe.TimedHandler will continue to fire.
2037 *
2038 * Users will not use Strophe.TimedHandler objects directly, but instead
2039 * they will use Strophe.Connection.addTimedHandler() and
2040 * Strophe.Connection.deleteTimedHandler().
2041 */
2042
2043 /** PrivateConstructor: Strophe.TimedHandler
2044 * Create and initialize a new Strophe.TimedHandler object.
2045 *
2046 * Parameters:
2047 * (Integer) period - The number of milliseconds to wait before the
2048 * handler is called.
2049 * (Function) handler - The callback to run when the handler fires. This
2050 * function should take no arguments.
2051 *
2052 * Returns:
2053 * A new Strophe.TimedHandler object.
2054 */
2055 Strophe.TimedHandler = function (period, handler)
2056 {
2057 this.period = period;
2058 this.handler = handler;
2059
2060 this.lastCalled = new Date().getTime();
2061 this.user = true;
2062 };
2063
2064 Strophe.TimedHandler.prototype = {
2065 /** PrivateFunction: run
2066 * Run the callback for the Strophe.TimedHandler.
2067 *
2068 * Returns:
2069 * true if the Strophe.TimedHandler should be called again, and false
2070 * otherwise.
2071 */
2072 run: function ()
2073 {
2074 this.lastCalled = new Date().getTime();
2075 return this.handler();
2076 },
2077
2078 /** PrivateFunction: reset
2079 * Reset the last called time for the Strophe.TimedHandler.
2080 */
2081 reset: function ()
2082 {
2083 this.lastCalled = new Date().getTime();
2084 },
2085
2086 /** PrivateFunction: toString
2087 * Get a string representation of the Strophe.TimedHandler object.
2088 *
2089 * Returns:
2090 * The string representation.
2091 */
2092 toString: function ()
2093 {
2094 return "{TimedHandler: " + this.handler + "(" + this.period +")}";
2095 }
2096 };
2097
2098 /** Class: Strophe.Connection
2099 * XMPP Connection manager.
2100 *
2101 * This class is the main part of Strophe. It manages a BOSH or websocket
2102 * connection to an XMPP server and dispatches events to the user callbacks
2103 * as data arrives. It supports SASL PLAIN, SASL DIGEST-MD5, SASL SCRAM-SHA1
2104 * and legacy authentication.
2105 *
2106 * After creating a Strophe.Connection object, the user will typically
2107 * call connect() with a user supplied callback to handle connection level
2108 * events like authentication failure, disconnection, or connection
2109 * complete.
2110 *
2111 * The user will also have several event handlers defined by using
2112 * addHandler() and addTimedHandler(). These will allow the user code to
2113 * respond to interesting stanzas or do something periodically with the
2114 * connection. These handlers will be active once authentication is
2115 * finished.
2116 *
2117 * To send data to the connection, use send().
2118 */
2119
2120 /** Constructor: Strophe.Connection
2121 * Create and initialize a Strophe.Connection object.
2122 *
2123 * The transport-protocol for this connection will be chosen automatically
2124 * based on the given service parameter. URLs starting with "ws://" or
2125 * "wss://" will use WebSockets, URLs starting with "http://", "https://"
2126 * or without a protocol will use BOSH.
2127 *
2128 * To make Strophe connect to the current host you can leave out the protocol
2129 * and host part and just pass the path, e.g.
2130 *
2131 * > var conn = new Strophe.Connection("/http-bind/");
2132 *
2133 * WebSocket options:
2134 *
2135 * If you want to connect to the current host with a WebSocket connection you
2136 * can tell Strophe to use WebSockets through a "protocol" attribute in the
2137 * optional options parameter. Valid values are "ws" for WebSocket and "wss"
2138 * for Secure WebSocket.
2139 * So to connect to "wss://CURRENT_HOSTNAME/xmpp-websocket" you would call
2140 *
2141 * > var conn = new Strophe.Connection("/xmpp-websocket/", {protocol: "wss"});
2142 *
2143 * Note that relative URLs _NOT_ starting with a "/" will also include the path
2144 * of the current site.
2145 *
2146 * Also because downgrading security is not permitted by browsers, when using
2147 * relative URLs both BOSH and WebSocket connections will use their secure
2148 * variants if the current connection to the site is also secure (https).
2149 *
2150 * BOSH options:
2151 *
2152 * By adding "sync" to the options, you can control if requests will
2153 * be made synchronously or not. The default behaviour is asynchronous.
2154 * If you want to make requests synchronous, make "sync" evaluate to true:
2155 * > var conn = new Strophe.Connection("/http-bind/", {sync: true});
2156 *
2157 * You can also toggle this on an already established connection:
2158 * > conn.options.sync = true;
2159 *
2160 * The "customHeaders" option can be used to provide custom HTTP headers to be
2161 * included in the XMLHttpRequests made.
2162 *
2163 * The "keepalive" option can be used to instruct Strophe to maintain the
2164 * current BOSH session across interruptions such as webpage reloads.
2165 *
2166 * It will do this by caching the sessions tokens in sessionStorage, and when
2167 * "restore" is called it will check whether there are cached tokens with
2168 * which it can resume an existing session.
2169 *
2170 * Parameters:
2171 * (String) service - The BOSH or WebSocket service URL.
2172 * (Object) options - A hash of configuration options
2173 *
2174 * Returns:
2175 * A new Strophe.Connection object.
2176 */
2177 Strophe.Connection = function (service, options)
2178 {
2179 //alert(service);
2180 // The service URL
2181 this.service = service;
2182
2183 // Configuration options
2184 this.options = options || {};
2185 var proto = this.options.protocol || "";
2186
2187 // Select protocal based on service or options
2188 if (service.indexOf("ws:") === 0 || service.indexOf("wss:") === 0 ||
2189 proto.indexOf("ws") === 0) {
2190 this._proto = new Strophe.Websocket(this);
2191 } else {
2192 this._proto = new Strophe.Bosh(this);
2193 }
2194
2195 /* The connected JID. */
2196 this.jid = "";
2197 /* the JIDs domain */
2198 this.domain = null;
2199 /* stream:features */
2200 this.features = null;
2201
2202 // SASL
2203 this._sasl_data = {};
2204 this.do_session = false;
2205 this.do_bind = false;
2206
2207 // handler lists
2208 this.timedHandlers = [];
2209 this.handlers = [];
2210 this.removeTimeds = [];
2211 this.removeHandlers = [];
2212 this.addTimeds = [];
2213 this.addHandlers = [];
2214
2215 this._authentication = {};
2216 this._idleTimeout = null;
2217 this._disconnectTimeout = null;
2218
2219 this.authenticated = false;
2220 this.connected = false;
2221 this.disconnecting = false;
2222 this.do_authentication = true;
2223 this.paused = false;
2224 this.restored = false;
2225
2226 this._data = [];
2227 this._uniqueId = 0;
2228
2229 this._sasl_success_handler = null;
2230 this._sasl_failure_handler = null;
2231 this._sasl_challenge_handler = null;
2232
2233 // Max retries before disconnecting
2234 this.maxRetries = 5;
2235
2236 // setup onIdle callback every 1/10th of a second
2237 this._idleTimeout = setTimeout(this._onIdle.bind(this), 100);
2238
2239 // initialize plugins
2240 for (var k in Strophe._connectionPlugins) {
2241 if (Strophe._connectionPlugins.hasOwnProperty(k)) {
2242 var ptype = Strophe._connectionPlugins[k];
2243 // jslint complaints about the below line, but this is fine
2244 var F = function () {}; // jshint ignore:line
2245 F.prototype = ptype;
2246 this[k] = new F();
2247 this[k].init(this);
2248 }
2249 }
2250 };
2251
2252 Strophe.Connection.prototype = {
2253 /** Function: reset
2254 * Reset the connection.
2255 *
2256 * This function should be called after a connection is disconnected
2257 * before that connection is reused.
2258 */
2259 reset: function ()
2260 {
2261 this._proto._reset();
2262
2263 // SASL
2264 this.do_session = false;
2265 this.do_bind = false;
2266
2267 // handler lists
2268 this.timedHandlers = [];
2269 this.handlers = [];
2270 this.removeTimeds = [];
2271 this.removeHandlers = [];
2272 this.addTimeds = [];
2273 this.addHandlers = [];
2274 this._authentication = {};
2275
2276 this.authenticated = false;
2277 this.connected = false;
2278 this.disconnecting = false;
2279 this.restored = false;
2280
2281 this._data = [];
2282 this._requests = [];
2283 this._uniqueId = 0;
2284 },
2285
2286 /** Function: pause
2287 * Pause the request manager.
2288 *
2289 * This will prevent Strophe from sending any more requests to the
2290 * server. This is very useful for temporarily pausing
2291 * BOSH-Connections while a lot of send() calls are happening quickly.
2292 * This causes Strophe to send the data in a single request, saving
2293 * many request trips.
2294 */
2295 pause: function ()
2296 {
2297 this.paused = true;
2298 },
2299
2300 /** Function: resume
2301 * Resume the request manager.
2302 *
2303 * This resumes after pause() has been called.
2304 */
2305 resume: function ()
2306 {
2307 this.paused = false;
2308 },
2309
2310 /** Function: getUniqueId
2311 * Generate a unique ID for use in <iq/> elements.
2312 *
2313 * All <iq/> stanzas are required to have unique id attributes. This
2314 * function makes creating these easy. Each connection instance has
2315 * a counter which starts from zero, and the value of this counter
2316 * plus a colon followed by the suffix becomes the unique id. If no
2317 * suffix is supplied, the counter is used as the unique id.
2318 *
2319 * Suffixes are used to make debugging easier when reading the stream
2320 * data, and their use is recommended. The counter resets to 0 for
2321 * every new connection for the same reason. For connections to the
2322 * same server that authenticate the same way, all the ids should be
2323 * the same, which makes it easy to see changes. This is useful for
2324 * automated testing as well.
2325 *
2326 * Parameters:
2327 * (String) suffix - A optional suffix to append to the id.
2328 *
2329 * Returns:
2330 * A unique string to be used for the id attribute.
2331 */
2332 getUniqueId: function (suffix)
2333 {
2334 if (typeof(suffix) == "string" || typeof(suffix) == "number") {
2335 return ++this._uniqueId + ":" + suffix;
2336 } else {
2337 return ++this._uniqueId + "";
2338 }
2339 },
2340
2341 /** Function: connect
2342 * Starts the connection process.
2343 *
2344 * As the connection process proceeds, the user supplied callback will
2345 * be triggered multiple times with status updates. The callback
2346 * should take two arguments - the status code and the error condition.
2347 *
2348 * The status code will be one of the values in the Strophe.Status
2349 * constants. The error condition will be one of the conditions
2350 * defined in RFC 3920 or the condition ‘strophe-parsererror‘.
2351 *
2352 * The Parameters _wait_, _hold_ and _route_ are optional and only relevant
2353 * for BOSH connections. Please see XEP 124 for a more detailed explanation
2354 * of the optional parameters.
2355 *
2356 * Parameters:
2357 * (String) jid - The user‘s JID. This may be a bare JID,
2358 * or a full JID. If a node is not supplied, SASL ANONYMOUS
2359 * authentication will be attempted.
2360 * (String) pass - The user‘s password.
2361 * (Function) callback - The connect callback function.
2362 * (Integer) wait - The optional HTTPBIND wait value. This is the
2363 * time the server will wait before returning an empty result for
2364 * a request. The default setting of 60 seconds is recommended.
2365 * (Integer) hold - The optional HTTPBIND hold value. This is the
2366 * number of connections the server will hold at one time. This
2367 * should almost always be set to 1 (the default).
2368 * (String) route - The optional route value.
2369 * (String) authcid - The optional alternative authentication identity
2370 * (username) if intending to impersonate another user.
2371 */
2372 connect: function (jid, pass, callback, wait, hold, route, authcid)
2373 {
2374 this.jid = jid;
2375 /** Variable: authzid
2376 * Authorization identity.
2377 */
2378 this.authzid = Strophe.getBareJidFromJid(this.jid);
2379 /** Variable: authcid
2380 * Authentication identity (User name).
2381 */
2382 this.authcid = authcid || Strophe.getNodeFromJid(this.jid);
2383 /** Variable: pass
2384 * Authentication identity (User password).
2385 */
2386 this.pass = pass;
2387 /** Variable: servtype
2388 * Digest MD5 compatibility.
2389 */
2390 this.servtype = "xmpp";
2391 this.connect_callback = callback;
2392 this.disconnecting = false;
2393 this.connected = false;
2394 this.authenticated = false;
2395 this.restored = false;
2396
2397 // parse jid for domain
2398 this.domain = Strophe.getDomainFromJid(this.jid);
2399
2400 this._changeConnectStatus(Strophe.Status.CONNECTING, null);
2401
2402 this._proto._connect(wait, hold, route);
2403 },
2404
2405 /** Function: attach
2406 * Attach to an already created and authenticated BOSH session.
2407 *
2408 * This function is provided to allow Strophe to attach to BOSH
2409 * sessions which have been created externally, perhaps by a Web
2410 * application. This is often used to support auto-login type features
2411 * without putting user credentials into the page.
2412 *
2413 * Parameters:
2414 * (String) jid - The full JID that is bound by the session.
2415 * (String) sid - The SID of the BOSH session.
2416 * (String) rid - The current RID of the BOSH session. This RID
2417 * will be used by the next request.
2418 * (Function) callback The connect callback function.
2419 * (Integer) wait - The optional HTTPBIND wait value. This is the
2420 * time the server will wait before returning an empty result for
2421 * a request. The default setting of 60 seconds is recommended.
2422 * Other settings will require tweaks to the Strophe.TIMEOUT value.
2423 * (Integer) hold - The optional HTTPBIND hold value. This is the
2424 * number of connections the server will hold at one time. This
2425 * should almost always be set to 1 (the default).
2426 * (Integer) wind - The optional HTTBIND window value. This is the
2427 * allowed range of request ids that are valid. The default is 5.
2428 */
2429 attach: function (jid, sid, rid, callback, wait, hold, wind)
2430 {
2431 if (this._proto instanceof Strophe.Bosh) {
2432 this._proto._attach(jid, sid, rid, callback, wait, hold, wind);
2433 } else {
2434 throw {
2435 name: ‘StropheSessionError‘,
2436 message: ‘The "attach" method can only be used with a BOSH connection.‘
2437 };
2438 }
2439 },
2440
2441 /** Function: restore
2442 * Attempt to restore a cached BOSH session.
2443 *
2444 * This function is only useful in conjunction with providing the
2445 * "keepalive":true option when instantiating a new Strophe.Connection.
2446 *
2447 * When "keepalive" is set to true, Strophe will cache the BOSH tokens
2448 * RID (Request ID) and SID (Session ID) and then when this function is
2449 * called, it will attempt to restore the session from those cached
2450 * tokens.
2451 *
2452 * This function must therefore be called instead of connect or attach.
2453 *
2454 * For an example on how to use it, please see examples/restore.js
2455 *
2456 * Parameters:
2457 * (String) jid - The user‘s JID. This may be a bare JID or a full JID.
2458 * (Function) callback - The connect callback function.
2459 * (Integer) wait - The optional HTTPBIND wait value. This is the
2460 * time the server will wait before returning an empty result for
2461 * a request. The default setting of 60 seconds is recommended.
2462 * (Integer) hold - The optional HTTPBIND hold value. This is the
2463 * number of connections the server will hold at one time. This
2464 * should almost always be set to 1 (the default).
2465 * (Integer) wind - The optional HTTBIND window value. This is the
2466 * allowed range of request ids that are valid. The default is 5.
2467 */
2468 restore: function (jid, callback, wait, hold, wind)
2469 {
2470 if (this._sessionCachingSupported()) {
2471 this._proto._restore(jid, callback, wait, hold, wind);
2472 } else {
2473 throw {
2474 name: ‘StropheSessionError‘,
2475 message: ‘The "restore" method can only be used with a BOSH connection.‘
2476 };
2477 }
2478 },
2479
2480 /** PrivateFunction: _sessionCachingSupported
2481 * Checks whether sessionStorage and JSON are supported and whether we‘re
2482 * using BOSH.
2483 */
2484 _sessionCachingSupported: function ()
2485 {
2486 if (this._proto instanceof Strophe.Bosh) {
2487 if (!JSON) { return false; }
2488 try {
2489 window.sessionStorage.setItem(‘_strophe_‘, ‘_strophe_‘);
2490 window.sessionStorage.removeItem(‘_strophe_‘);
2491 } catch (e) {
2492 return false;
2493 }
2494 return true;
2495 }
2496 return false;
2497 },
2498
2499 /** Function: xmlInput
2500 * User overrideable function that receives XML data coming into the
2501 * connection.
2502 *
2503 * The default function does nothing. User code can override this with
2504 * > Strophe.Connection.xmlInput = function (elem) {
2505 * > (user code)
2506 * > };
2507 *
2508 * Due to limitations of current Browsers‘ XML-Parsers the opening and closing
2509 * <stream> tag for WebSocket-Connoctions will be passed as selfclosing here.
2510 *
2511 * BOSH-Connections will have all stanzas wrapped in a <body> tag. See
2512 * <Strophe.Bosh.strip> if you want to strip this tag.
2513 *
2514 * Parameters:
2515 * (XMLElement) elem - The XML data received by the connection.
2516 */
2517 /* jshint unused:false */
2518 xmlInput: function (elem)
2519 {
2520 return;
2521 },
2522 /* jshint unused:true */
2523
2524 /** Function: xmlOutput
2525 * User overrideable function that receives XML data sent to the
2526 * connection.
2527 *
2528 * The default function does nothing. User code can override this with
2529 * > Strophe.Connection.xmlOutput = function (elem) {
2530 * > (user code)
2531 * > };
2532 *
2533 * Due to limitations of current Browsers‘ XML-Parsers the opening and closing
2534 * <stream> tag for WebSocket-Connoctions will be passed as selfclosing here.
2535 *
2536 * BOSH-Connections will have all stanzas wrapped in a <body> tag. See
2537 * <Strophe.Bosh.strip> if you want to strip this tag.
2538 *
2539 * Parameters:
2540 * (XMLElement) elem - The XMLdata sent by the connection.
2541 */
2542 /* jshint unused:false */
2543 xmlOutput: function (elem)
2544 {
2545 return;
2546 },
2547 /* jshint unused:true */
2548
2549 /** Function: rawInput
2550 * User overrideable function that receives raw data coming into the
2551 * connection.
2552 *
2553 * The default function does nothing. User code can override this with
2554 * > Strophe.Connection.rawInput = function (data) {
2555 * > (user code)
2556 * > };
2557 *
2558 * Parameters:
2559 * (String) data - The data received by the connection.
2560 */
2561 /* jshint unused:false */
2562 rawInput: function (data)
2563 {
2564 return;
2565 },
2566 /* jshint unused:true */
2567
2568 /** Function: rawOutput
2569 * User overrideable function that receives raw data sent to the
2570 * connection.
2571 *
2572 * The default function does nothing. User code can override this with
2573 * > Strophe.Connection.rawOutput = function (data) {
2574 * > (user code)
2575 * > };
2576 *
2577 * Parameters:
2578 * (String) data - The data sent by the connection.
2579 */
2580 /* jshint unused:false */
2581 rawOutput: function (data)
2582 {
2583 return;
2584 },
2585 /* jshint unused:true */
2586
2587 /** Function: send
2588 * Send a stanza.
2589 *
2590 * This function is called to push data onto the send queue to
2591 * go out over the wire. Whenever a request is sent to the BOSH
2592 * server, all pending data is sent and the queue is flushed.
2593 *
2594 * Parameters:
2595 * (XMLElement |
2596 * [XMLElement] |
2597 * Strophe.Builder) elem - The stanza to send.
2598 */
2599 send: function (elem)
2600 {
2601 if (elem === null) { return ; }
2602 if (typeof(elem.sort) === "function") {
2603 for (var i = 0; i < elem.length; i++) {
2604 this._queueData(elem[i]);
2605 }
2606 } else if (typeof(elem.tree) === "function") {
2607 this._queueData(elem.tree());
2608 } else {
2609 this._queueData(elem);
2610 }
2611
2612 this._proto._send();
2613 },
2614
2615 /** Function: flush
2616 * Immediately send any pending outgoing data.
2617 *
2618 * Normally send() queues outgoing data until the next idle period
2619 * (100ms), which optimizes network use in the common cases when
2620 * several send()s are called in succession. flush() can be used to
2621 * immediately send all pending data.
2622 */
2623 flush: function ()
2624 {
2625 // cancel the pending idle period and run the idle function
2626 // immediately
2627 clearTimeout(this._idleTimeout);
2628 this._onIdle();
2629 },
2630
2631 /** Function: sendIQ
2632 * Helper function to send IQ stanzas.
2633 *
2634 * Parameters:
2635 * (XMLElement) elem - The stanza to send.
2636 * (Function) callback - The callback function for a successful request.
2637 * (Function) errback - The callback function for a failed or timed
2638 * out request. On timeout, the stanza will be null.
2639 * (Integer) timeout - The time specified in milliseconds for a
2640 * timeout to occur.
2641 *
2642 * Returns:
2643 * The id used to send the IQ.
2644 */
2645 sendIQ: function(elem, callback, errback, timeout) {
2646 var timeoutHandler = null;
2647 var that = this;
2648
2649 if (typeof(elem.tree) === "function") {
2650 elem = elem.tree();
2651 }
2652 var id = elem.getAttribute(‘id‘);
2653
2654 // inject id if not found
2655 if (!id) {
2656 id = this.getUniqueId("sendIQ");
2657 elem.setAttribute("id", id);
2658 }
2659
2660 var expectedFrom = elem.getAttribute("to");
2661 var fulljid = this.jid;
2662
2663 var handler = this.addHandler(function (stanza) {
2664 // remove timeout handler if there is one
2665 if (timeoutHandler) {
2666 that.deleteTimedHandler(timeoutHandler);
2667 }
2668
2669 var acceptable = false;
2670 var from = stanza.getAttribute("from");
2671 if (from === expectedFrom ||
2672 (expectedFrom === null &&
2673 (from === Strophe.getBareJidFromJid(fulljid) ||
2674 from === Strophe.getDomainFromJid(fulljid) ||
2675 from === fulljid))) {
2676 acceptable = true;
2677 }
2678
2679 if (!acceptable) {
2680 throw {
2681 name: "StropheError",
2682 message: "Got answer to IQ from wrong jid:" + from +
2683 "\nExpected jid: " + expectedFrom
2684 };
2685 }
2686
2687 var iqtype = stanza.getAttribute(‘type‘);
2688 if (iqtype == ‘result‘) {
2689 if (callback) {
2690 callback(stanza);
2691 }
2692 } else if (iqtype == ‘error‘) {
2693 if (errback) {
2694 errback(stanza);
2695 }
2696 } else {
2697 throw {
2698 name: "StropheError",
2699 message: "Got bad IQ type of " + iqtype
2700 };
2701 }
2702 }, null, ‘iq‘, [‘error‘, ‘result‘], id);
2703
2704 // if timeout specified, setup timeout handler.
2705 if (timeout) {
2706 timeoutHandler = this.addTimedHandler(timeout, function () {
2707 // get rid of normal handler
2708 that.deleteHandler(handler);
2709 // call errback on timeout with null stanza
2710 if (errback) {
2711 errback(null);
2712 }
2713 return false;
2714 });
2715 }
2716 this.send(elem);
2717 return id;
2718 },
2719
2720 /** PrivateFunction: _queueData
2721 * Queue outgoing data for later sending. Also ensures that the data
2722 * is a DOMElement.
2723 */
2724 _queueData: function (element) {
2725 if (element === null ||
2726 !element.tagName ||
2727 !element.childNodes) {
2728 throw {
2729 name: "StropheError",
2730 message: "Cannot queue non-DOMElement."
2731 };
2732 }
2733
2734 this._data.push(element);
2735 },
2736
2737 /** PrivateFunction: _sendRestart
2738 * Send an xmpp:restart stanza.
2739 */
2740 _sendRestart: function ()
2741 {
2742 this._data.push("restart");
2743
2744 this._proto._sendRestart();
2745
2746 this._idleTimeout = setTimeout(this._onIdle.bind(this), 100);
2747 },
2748
2749 /** Function: addTimedHandler
2750 * Add a timed handler to the connection.
2751 *
2752 * This function adds a timed handler. The provided handler will
2753 * be called every period milliseconds until it returns false,
2754 * the connection is terminated, or the handler is removed. Handlers
2755 * that wish to continue being invoked should return true.
2756 *
2757 * Because of method binding it is necessary to save the result of
2758 * this function if you wish to remove a handler with
2759 * deleteTimedHandler().
2760 *
2761 * Note that user handlers are not active until authentication is
2762 * successful.
2763 *
2764 * Parameters:
2765 * (Integer) period - The period of the handler.
2766 * (Function) handler - The callback function.
2767 *
2768 * Returns:
2769 * A reference to the handler that can be used to remove it.
2770 */
2771 addTimedHandler: function (period, handler)
2772 {
2773 var thand = new Strophe.TimedHandler(period, handler);
2774 this.addTimeds.push(thand);
2775 return thand;
2776 },
2777
2778 /** Function: deleteTimedHandler
2779 * Delete a timed handler for a connection.
2780 *
2781 * This function removes a timed handler from the connection. The
2782 * handRef parameter is *not* the function passed to addTimedHandler(),
2783 * but is the reference returned from addTimedHandler().
2784 *
2785 * Parameters:
2786 * (Strophe.TimedHandler) handRef - The handler reference.
2787 */
2788 deleteTimedHandler: function (handRef)
2789 {
2790 // this must be done in the Idle loop so that we don‘t change
2791 // the handlers during iteration
2792 this.removeTimeds.push(handRef);
2793 },
2794
2795 /** Function: addHandler
2796 * Add a stanza handler for the connection.
2797 *
2798 * This function adds a stanza handler to the connection. The
2799 * handler callback will be called for any stanza that matches
2800 * the parameters. Note that if multiple parameters are supplied,
2801 * they must all match for the handler to be invoked.
2802 *
2803 * The handler will receive the stanza that triggered it as its argument.
2804 * *The handler should return true if it is to be invoked again;
2805 * returning false will remove the handler after it returns.*
2806 *
2807 * As a convenience, the ns parameters applies to the top level element
2808 * and also any of its immediate children. This is primarily to make
2809 * matching /iq/query elements easy.
2810 *
2811 * The options argument contains handler matching flags that affect how
2812 * matches are determined. Currently the only flag is matchBare (a
2813 * boolean). When matchBare is true, the from parameter and the from
2814 * attribute on the stanza will be matched as bare JIDs instead of
2815 * full JIDs. To use this, pass {matchBare: true} as the value of
2816 * options. The default value for matchBare is false.
2817 *
2818 * The return value should be saved if you wish to remove the handler
2819 * with deleteHandler().
2820 *
2821 * Parameters:
2822 * (Function) handler - The user callback.
2823 * (String) ns - The namespace to match.
2824 * (String) name - The stanza name to match.
2825 * (String) type - The stanza type attribute to match.
2826 * (String) id - The stanza id attribute to match.
2827 * (String) from - The stanza from attribute to match.
2828 * (String) options - The handler options
2829 *
2830 * Returns:
2831 * A reference to the handler that can be used to remove it.
2832 */
2833 addHandler: function (handler, ns, name, type, id, from, options)
2834 {
2835 var hand = new Strophe.Handler(handler, ns, name, type, id, from, options);
2836 this.addHandlers.push(hand);
2837 return hand;
2838 },
2839
2840 /** Function: deleteHandler
2841 * Delete a stanza handler for a connection.
2842 *
2843 * This function removes a stanza handler from the connection. The
2844 * handRef parameter is *not* the function passed to addHandler(),
2845 * but is the reference returned from addHandler().
2846 *
2847 * Parameters:
2848 * (Strophe.Handler) handRef - The handler reference.
2849 */
2850 deleteHandler: function (handRef)
2851 {
2852 // this must be done in the Idle loop so that we don‘t change
2853 // the handlers during iteration
2854 this.removeHandlers.push(handRef);
2855 // If a handler is being deleted while it is being added,
2856 // prevent it from getting added
2857 var i = this.addHandlers.indexOf(handRef);
2858 if (i >= 0) {
2859 this.addHandlers.splice(i, 1);
2860 }
2861 },
2862
2863 /** Function: disconnect
2864 * Start the graceful disconnection process.
2865 *
2866 * This function starts the disconnection process. This process starts
2867 * by sending unavailable presence and sending BOSH body of type
2868 * terminate. A timeout handler makes sure that disconnection happens
2869 * even if the BOSH server does not respond.
2870 * If the Connection object isn‘t connected, at least tries to abort all pending requests
2871 * so the connection object won‘t generate successful requests (which were already opened).
2872 *
2873 * The user supplied connection callback will be notified of the
2874 * progress as this process happens.
2875 *
2876 * Parameters:
2877 * (String) reason - The reason the disconnect is occuring.
2878 */
2879 disconnect: function (reason)
2880 {
2881 this._changeConnectStatus(Strophe.Status.DISCONNECTING, reason);
2882
2883 Strophe.info("Disconnect was called because: " + reason);
2884 if (this.connected) {
2885 var pres = false;
2886 this.disconnecting = true;
2887 if (this.authenticated) {
2888 pres = $pres({
2889 xmlns: Strophe.NS.CLIENT,
2890 type: ‘unavailable‘
2891 });
2892 }
2893 // setup timeout handler
2894 this._disconnectTimeout = this._addSysTimedHandler(
2895 3000, this._onDisconnectTimeout.bind(this));
2896 this._proto._disconnect(pres);
2897 } else {
2898 Strophe.info("Disconnect was called before Strophe connected to the server");
2899 this._proto._abortAllRequests();
2900 }
2901 },
2902
2903 /** PrivateFunction: _changeConnectStatus
2904 * _Private_ helper function that makes sure plugins and the user‘s
2905 * callback are notified of connection status changes.
2906 *
2907 * Parameters:
2908 * (Integer) status - the new connection status, one of the values
2909 * in Strophe.Status
2910 * (String) condition - the error condition or null
2911 */
2912 _changeConnectStatus: function (status, condition)
2913 {
2914 // notify all plugins listening for status changes
2915 for (var k in Strophe._connectionPlugins) {
2916 if (Strophe._connectionPlugins.hasOwnProperty(k)) {
2917 var plugin = this[k];
2918 if (plugin.statusChanged) {
2919 try {
2920 plugin.statusChanged(status, condition);
2921 } catch (err) {
2922 Strophe.error("" + k + " plugin caused an exception " +
2923 "changing status: " + err);
2924 }
2925 }
2926 }
2927 }
2928
2929 // notify the user‘s callback
2930 if (this.connect_callback) {
2931 try {
2932 this.connect_callback(status, condition);
2933 } catch (e) {
2934 Strophe.error("User connection callback caused an " +
2935 "exception: " + e);
2936 }
2937 }
2938 },
2939
2940 /** PrivateFunction: _doDisconnect
2941 * _Private_ function to disconnect.
2942 *
2943 * This is the last piece of the disconnection logic. This resets the
2944 * connection and alerts the user‘s connection callback.
2945 */
2946 _doDisconnect: function (condition)
2947 {
2948 if (typeof this._idleTimeout == "number") {
2949 clearTimeout(this._idleTimeout);
2950 }
2951
2952 // Cancel Disconnect Timeout
2953 if (this._disconnectTimeout !== null) {
2954 this.deleteTimedHandler(this._disconnectTimeout);
2955 this._disconnectTimeout = null;
2956 }
2957
2958 Strophe.info("_doDisconnect was called");
2959 this._proto._doDisconnect();
2960
2961 this.authenticated = false;
2962 this.disconnecting = false;
2963 this.restored = false;
2964
2965 // delete handlers
2966 this.handlers = [];
2967 this.timedHandlers = [];
2968 this.removeTimeds = [];
2969 this.removeHandlers = [];
2970 this.addTimeds = [];
2971 this.addHandlers = [];
2972
2973 // tell the parent we disconnected
2974 this._changeConnectStatus(Strophe.Status.DISCONNECTED, condition);
2975 this.connected = false;
2976 },
2977
2978 /** PrivateFunction: _dataRecv
2979 * _Private_ handler to processes incoming data from the the connection.
2980 *
2981 * Except for _connect_cb handling the initial connection request,
2982 * this function handles the incoming data for all requests. This
2983 * function also fires stanza handlers that match each incoming
2984 * stanza.
2985 *
2986 * Parameters:
2987 * (Strophe.Request) req - The request that has data ready.
2988 * (string) req - The stanza a raw string (optiona).
2989 */
2990 _dataRecv: function (req, raw)
2991 {
2992 Strophe.info("_dataRecv called");
2993 var elem = this._proto._reqToData(req);
2994 if (elem === null) { return; }
2995
2996 if (this.xmlInput !== Strophe.Connection.prototype.xmlInput) {
2997 if (elem.nodeName === this._proto.strip && elem.childNodes.length) {
2998 this.xmlInput(elem.childNodes[0]);
2999 } else {
3000 this.xmlInput(elem);
3001 }
3002 }
3003 if (this.rawInput !== Strophe.Connection.prototype.rawInput) {
3004 if (raw) {
3005 this.rawInput(raw);
3006 } else {
3007 this.rawInput(Strophe.serialize(elem));
3008 }
3009 }
3010
3011 // remove handlers scheduled for deletion
3012 var i, hand;
3013 while (this.removeHandlers.length > 0) {
3014 hand = this.removeHandlers.pop();
3015 i = this.handlers.indexOf(hand);
3016 if (i >= 0) {
3017 this.handlers.splice(i, 1);
3018 }
3019 }
3020
3021 // add handlers scheduled for addition
3022 while (this.addHandlers.length > 0) {
3023 this.handlers.push(this.addHandlers.pop());
3024 }
3025
3026 // handle graceful disconnect
3027 if (this.disconnecting && this._proto._emptyQueue()) {
3028 this._doDisconnect();
3029 return;
3030 }
3031
3032 var type = elem.getAttribute("type");
3033 var cond, conflict;
3034 if (type !== null && type == "terminate") {
3035 // Don‘t process stanzas that come in after disconnect
3036 if (this.disconnecting) {
3037 return;
3038 }
3039
3040 // an error occurred
3041 cond = elem.getAttribute("condition");
3042 conflict = elem.getElementsByTagName("conflict");
3043 if (cond !== null) {
3044 if (cond == "remote-stream-error" && conflict.length > 0) {
3045 cond = "conflict";
3046 }
3047 this._changeConnectStatus(Strophe.Status.CONNFAIL, cond);
3048 } else {
3049 this._changeConnectStatus(Strophe.Status.CONNFAIL, "unknown");
3050 }
3051 this._doDisconnect(cond);
3052 return;
3053 }
3054
3055 // send each incoming stanza through the handler chain
3056 var that = this;
3057 Strophe.forEachChild(elem, null, function (child) {
3058 var i, newList;
3059 // process handlers
3060 newList = that.handlers;
3061 that.handlers = [];
3062 for (i = 0; i < newList.length; i++) {
3063 var hand = newList[i];
3064 // encapsulate ‘handler.run‘ not to lose the whole handler list if
3065 // one of the handlers throws an exception
3066 try {
3067 if (hand.isMatch(child) &&
3068 (that.authenticated || !hand.user)) {
3069 if (hand.run(child)) {
3070 that.handlers.push(hand);
3071 }
3072 } else {
3073 that.handlers.push(hand);
3074 }
3075 } catch(e) {
3076 // if the handler throws an exception, we consider it as false
3077 Strophe.warn(‘Removing Strophe handlers due to uncaught exception: ‘ + e.message);
3078 }
3079 }
3080 });
3081 },
3082
3083
3084 /** Attribute: mechanisms
3085 * SASL Mechanisms available for Conncection.
3086 */
3087 mechanisms: {},
3088
3089 /** PrivateFunction: _connect_cb
3090 * _Private_ handler for initial connection request.
3091 *
3092 * This handler is used to process the initial connection request
3093 * response from the BOSH server. It is used to set up authentication
3094 * handlers and start the authentication process.
3095 *
3096 * SASL authentication will be attempted if available, otherwise
3097 * the code will fall back to legacy authentication.
3098 *
3099 * Parameters:
3100 * (Strophe.Request) req - The current request.
3101 * (Function) _callback - low level (xmpp) connect callback function.
3102 * Useful for plugins with their own xmpp connect callback (when their)
3103 * want to do something special).
3104 */
3105 _connect_cb: function (req, _callback, raw)
3106 {
3107 Strophe.info("_connect_cb was called");
3108
3109 this.connected = true;
3110
3111 var bodyWrap = this._proto._reqToData(req);
3112 if (!bodyWrap) { return; }
3113
3114 if (this.xmlInput !== Strophe.Connection.prototype.xmlInput) {
3115 if (bodyWrap.nodeName === this._proto.strip && bodyWrap.childNodes.length) {
3116 this.xmlInput(bodyWrap.childNodes[0]);
3117 } else {
3118 this.xmlInput(bodyWrap);
3119 }
3120 }
3121 if (this.rawInput !== Strophe.Connection.prototype.rawInput) {
3122 if (raw) {
3123 this.rawInput(raw);
3124 } else {
3125 this.rawInput(Strophe.serialize(bodyWrap));
3126 }
3127 }
3128
3129 var conncheck = this._proto._connect_cb(bodyWrap);
3130 if (conncheck === Strophe.Status.CONNFAIL) {
3131 return;
3132 }
3133
3134 this._authentication.sasl_scram_sha1 = false;
3135 this._authentication.sasl_plain = false;
3136 this._authentication.sasl_digest_md5 = false;
3137 this._authentication.sasl_anonymous = false;
3138
3139 this._authentication.legacy_auth = false;
3140
3141 // Check for the stream:features tag
3142 var hasFeatures;
3143 if (bodyWrap.getElementsByTagNameNS) {
3144 hasFeatures = bodyWrap.getElementsByTagNameNS(Strophe.NS.STREAM, "features").length > 0;
3145 } else {
3146 hasFeatures = bodyWrap.getElementsByTagName("stream:features").length > 0 || bodyWrap.getElementsByTagName("features").length > 0;
3147 }
3148 var mechanisms = bodyWrap.getElementsByTagName("mechanism");
3149 var matched = [];
3150 var i, mech, found_authentication = false;
3151 if (!hasFeatures) {
3152 this._proto._no_auth_received(_callback);
3153 return;
3154 }
3155 if (mechanisms.length > 0) {
3156 for (i = 0; i < mechanisms.length; i++) {
3157 mech = Strophe.getText(mechanisms[i]);
3158 if (this.mechanisms[mech]) matched.push(this.mechanisms[mech]);
3159 }
3160 }
3161 this._authentication.legacy_auth =
3162 bodyWrap.getElementsByTagName("auth").length > 0;
3163 found_authentication = this._authentication.legacy_auth ||
3164 matched.length > 0;
3165 if (!found_authentication) {
3166 this._proto._no_auth_received(_callback);
3167 return;
3168 }
3169 if (this.do_authentication !== false)
3170 this.authenticate(matched);
3171 },
3172
3173 /** Function: authenticate
3174 * Set up authentication
3175 *
3176 * Contiunues the initial connection request by setting up authentication
3177 * handlers and start the authentication process.
3178 *
3179 * SASL authentication will be attempted if available, otherwise
3180 * the code will fall back to legacy authentication.
3181 *
3182 */
3183 authenticate: function (matched)
3184 {
3185 var i;
3186 // Sorting matched mechanisms according to priority.
3187 for (i = 0; i < matched.length - 1; ++i) {
3188 var higher = i;
3189 for (var j = i + 1; j < matched.length; ++j) {
3190 if (matched[j].prototype.priority > matched[higher].prototype.priority) {
3191 higher = j;
3192 }
3193 }
3194 if (higher != i) {
3195 var swap = matched[i];
3196 matched[i] = matched[higher];
3197 matched[higher] = swap;
3198 }
3199 }
3200
3201 // run each mechanism
3202 var mechanism_found = false;
3203 for (i = 0; i < matched.length; ++i) {
3204 if (!matched[i].test(this)) continue;
3205
3206 this._sasl_success_handler = this._addSysHandler(
3207 this._sasl_success_cb.bind(this), null,
3208 "success", null, null);
3209 this._sasl_failure_handler = this._addSysHandler(
3210 this._sasl_failure_cb.bind(this), null,
3211 "failure", null, null);
3212 this._sasl_challenge_handler = this._addSysHandler(
3213 this._sasl_challenge_cb.bind(this), null,
3214 "challenge", null, null);
3215
3216 this._sasl_mechanism = new matched[i]();
3217 this._sasl_mechanism.onStart(this);
3218
3219 var request_auth_exchange = $build("auth", {
3220 xmlns: Strophe.NS.SASL,
3221 mechanism: this._sasl_mechanism.name
3222 });
3223
3224 if (this._sasl_mechanism.isClientFirst) {
3225 var response = this._sasl_mechanism.onChallenge(this, null);
3226 request_auth_exchange.t(Base64.encode(response));
3227 }
3228
3229 this.send(request_auth_exchange.tree());
3230
3231 mechanism_found = true;
3232 break;
3233 }
3234
3235 if (!mechanism_found) {
3236 // if none of the mechanism worked
3237 if (Strophe.getNodeFromJid(this.jid) === null) {
3238 // we don‘t have a node, which is required for non-anonymous
3239 // client connections
3240 this._changeConnectStatus(Strophe.Status.CONNFAIL,
3241 ‘x-strophe-bad-non-anon-jid‘);
3242 this.disconnect(‘x-strophe-bad-non-anon-jid‘);
3243 } else {
3244 // fall back to legacy authentication
3245 this._changeConnectStatus(Strophe.Status.AUTHENTICATING, null);
3246 this._addSysHandler(this._auth1_cb.bind(this), null, null,
3247 null, "_auth_1");
3248
3249 this.send($iq({
3250 type: "get",
3251 to: this.domain,
3252 id: "_auth_1"
3253 }).c("query", {
3254 xmlns: Strophe.NS.AUTH
3255 }).c("username", {}).t(Strophe.getNodeFromJid(this.jid)).tree());
3256 }
3257 }
3258
3259 },
3260
3261 _sasl_challenge_cb: function(elem) {
3262 var challenge = Base64.decode(Strophe.getText(elem));
3263 var response = this._sasl_mechanism.onChallenge(this, challenge);
3264
3265 var stanza = $build(‘response‘, {
3266 xmlns: Strophe.NS.SASL
3267 });
3268 if (response !== "") {
3269 stanza.t(Base64.encode(response));
3270 }
3271 this.send(stanza.tree());
3272
3273 return true;
3274 },
3275
3276 /** PrivateFunction: _auth1_cb
3277 * _Private_ handler for legacy authentication.
3278 *
3279 * This handler is called in response to the initial <iq type=‘get‘/>
3280 * for legacy authentication. It builds an authentication <iq/> and
3281 * sends it, creating a handler (calling back to _auth2_cb()) to
3282 * handle the result
3283 *
3284 * Parameters:
3285 * (XMLElement) elem - The stanza that triggered the callback.
3286 *
3287 * Returns:
3288 * false to remove the handler.
3289 */
3290 /* jshint unused:false */
3291 _auth1_cb: function (elem)
3292 {
3293 // build plaintext auth iq
3294 var iq = $iq({type: "set", id: "_auth_2"})
3295 .c(‘query‘, {xmlns: Strophe.NS.AUTH})
3296 .c(‘username‘, {}).t(Strophe.getNodeFromJid(this.jid))
3297 .up()
3298 .c(‘password‘).t(this.pass);
3299
3300 if (!Strophe.getResourceFromJid(this.jid)) {
3301 // since the user has not supplied a resource, we pick
3302 // a default one here. unlike other auth methods, the server
3303 // cannot do this for us.
3304 this.jid = Strophe.getBareJidFromJid(this.jid) + ‘/strophe‘;
3305 }
3306 iq.up().c(‘resource‘, {}).t(Strophe.getResourceFromJid(this.jid));
3307
3308 this._addSysHandler(this._auth2_cb.bind(this), null,
3309 null, null, "_auth_2");
3310
3311 this.send(iq.tree());
3312
3313 return false;
3314 },
3315 /* jshint unused:true */
3316
3317 /** PrivateFunction: _sasl_success_cb
3318 * _Private_ handler for succesful SASL authentication.
3319 *
3320 * Parameters:
3321 * (XMLElement) elem - The matching stanza.
3322 *
3323 * Returns:
3324 * false to remove the handler.
3325 */
3326 _sasl_success_cb: function (elem)
3327 {
3328 if (this._sasl_data["server-signature"]) {
3329 var serverSignature;
3330 var success = Base64.decode(Strophe.getText(elem));
3331 var attribMatch = /([a-z]+)=([^,]+)(,|$)/;
3332 var matches = success.match(attribMatch);
3333 if (matches[1] == "v") {
3334 serverSignature = matches[2];
3335 }
3336
3337 if (serverSignature != this._sasl_data["server-signature"]) {
3338 // remove old handlers
3339 this.deleteHandler(this._sasl_failure_handler);
3340 this._sasl_failure_handler = null;
3341 if (this._sasl_challenge_handler) {
3342 this.deleteHandler(this._sasl_challenge_handler);
3343 this._sasl_challenge_handler = null;
3344 }
3345
3346 this._sasl_data = {};
3347 return this._sasl_failure_cb(null);
3348 }
3349 }
3350
3351 Strophe.info("SASL authentication succeeded.");
3352
3353 if(this._sasl_mechanism)
3354 this._sasl_mechanism.onSuccess();
3355
3356 // remove old handlers
3357 this.deleteHandler(this._sasl_failure_handler);
3358 this._sasl_failure_handler = null;
3359 if (this._sasl_challenge_handler) {
3360 this.deleteHandler(this._sasl_challenge_handler);
3361 this._sasl_challenge_handler = null;
3362 }
3363
3364 var streamfeature_handlers = [];
3365 var wrapper = function(handlers, elem) {
3366 while (handlers.length) {
3367 this.deleteHandler(handlers.pop());
3368 }
3369 this._sasl_auth1_cb.bind(this)(elem);
3370 return false;
3371 };
3372 streamfeature_handlers.push(this._addSysHandler(function(elem) {
3373 wrapper.bind(this)(streamfeature_handlers, elem);
3374 }.bind(this), null, "stream:features", null, null));
3375 streamfeature_handlers.push(this._addSysHandler(function(elem) {
3376 wrapper.bind(this)(streamfeature_handlers, elem);
3377 }.bind(this), Strophe.NS.STREAM, "features", null, null));
3378
3379 // we must send an xmpp:restart now
3380 this._sendRestart();
3381
3382 return false;
3383 },
3384
3385 /** PrivateFunction: _sasl_auth1_cb
3386 * _Private_ handler to start stream binding.
3387 *
3388 * Parameters:
3389 * (XMLElement) elem - The matching stanza.
3390 *
3391 * Returns:
3392 * false to remove the handler.
3393 */
3394 _sasl_auth1_cb: function (elem)
3395 {
3396 // save stream:features for future usage
3397 this.features = elem;
3398
3399 var i, child;
3400
3401 for (i = 0; i < elem.childNodes.length; i++) {
3402 child = elem.childNodes[i];
3403 if (child.nodeName == ‘bind‘) {
3404 this.do_bind = true;
3405 }
3406
3407 if (child.nodeName == ‘session‘) {
3408 this.do_session = true;
3409 }
3410 }
3411
3412 if (!this.do_bind) {
3413 this._changeConnectStatus(Strophe.Status.AUTHFAIL, null);
3414 return false;
3415 } else {
3416 this._addSysHandler(this._sasl_bind_cb.bind(this), null, null,
3417 null, "_bind_auth_2");
3418
3419 var resource = Strophe.getResourceFromJid(this.jid);
3420 if (resource) {
3421 this.send($iq({type: "set", id: "_bind_auth_2"})
3422 .c(‘bind‘, {xmlns: Strophe.NS.BIND})
3423 .c(‘resource‘, {}).t(resource).tree());
3424 } else {
3425 this.send($iq({type: "set", id: "_bind_auth_2"})
3426 .c(‘bind‘, {xmlns: Strophe.NS.BIND})
3427 .tree());
3428 }
3429 }
3430
3431 return false;
3432 },
3433
3434 /** PrivateFunction: _sasl_bind_cb
3435 * _Private_ handler for binding result and session start.
3436 *
3437 * Parameters:
3438 * (XMLElement) elem - The matching stanza.
3439 *
3440 * Returns:
3441 * false to remove the handler.
3442 */
3443 _sasl_bind_cb: function (elem)
3444 {
3445 if (elem.getAttribute("type") == "error") {
3446 Strophe.info("SASL binding failed.");
3447 var conflict = elem.getElementsByTagName("conflict"), condition;
3448 if (conflict.length > 0) {
3449 condition = ‘conflict‘;
3450 }
3451 this._changeConnectStatus(Strophe.Status.AUTHFAIL, condition);
3452 return false;
3453 }
3454
3455 // TODO - need to grab errors
3456 var bind = elem.getElementsByTagName("bind");
3457 var jidNode;
3458 if (bind.length > 0) {
3459 // Grab jid
3460 jidNode = bind[0].getElementsByTagName("jid");
3461 if (jidNode.length > 0) {
3462 this.jid = Strophe.getText(jidNode[0]);
3463
3464 if (this.do_session) {
3465 this._addSysHandler(this._sasl_session_cb.bind(this),
3466 null, null, null, "_session_auth_2");
3467
3468 this.send($iq({type: "set", id: "_session_auth_2"})
3469 .c(‘session‘, {xmlns: Strophe.NS.SESSION})
3470 .tree());
3471 } else {
3472 this.authenticated = true;
3473 this._changeConnectStatus(Strophe.Status.CONNECTED, null);
3474 }
3475 }
3476 } else {
3477 Strophe.info("SASL binding failed.");
3478 this._changeConnectStatus(Strophe.Status.AUTHFAIL, null);
3479 return false;
3480 }
3481 },
3482
3483 /** PrivateFunction: _sasl_session_cb
3484 * _Private_ handler to finish successful SASL connection.
3485 *
3486 * This sets Connection.authenticated to true on success, which
3487 * starts the processing of user handlers.
3488 *
3489 * Parameters:
3490 * (XMLElement) elem - The matching stanza.
3491 *
3492 * Returns:
3493 * false to remove the handler.
3494 */
3495 _sasl_session_cb: function (elem)
3496 {
3497 if (elem.getAttribute("type") == "result") {
3498 this.authenticated = true;
3499 this._changeConnectStatus(Strophe.Status.CONNECTED, null);
3500 } else if (elem.getAttribute("type") == "error") {
3501 Strophe.info("Session creation failed.");
3502 this._changeConnectStatus(Strophe.Status.AUTHFAIL, null);
3503 return false;
3504 }
3505
3506 return false;
3507 },
3508
3509 /** PrivateFunction: _sasl_failure_cb
3510 * _Private_ handler for SASL authentication failure.
3511 *
3512 * Parameters:
3513 * (XMLElement) elem - The matching stanza.
3514 *
3515 * Returns:
3516 * false to remove the handler.
3517 */
3518 /* jshint unused:false */
3519 _sasl_failure_cb: function (elem)
3520 {
3521 // delete unneeded handlers
3522 if (this._sasl_success_handler) {
3523 this.deleteHandler(this._sasl_success_handler);
3524 this._sasl_success_handler = null;
3525 }
3526 if (this._sasl_challenge_handler) {
3527 this.deleteHandler(this._sasl_challenge_handler);
3528 this._sasl_challenge_handler = null;
3529 }
3530
3531 if(this._sasl_mechanism)
3532 this._sasl_mechanism.onFailure();
3533 this._changeConnectStatus(Strophe.Status.AUTHFAIL, null);
3534 return false;
3535 },
3536 /* jshint unused:true */
3537
3538 /** PrivateFunction: _auth2_cb
3539 * _Private_ handler to finish legacy authentication.
3540 *
3541 * This handler is called when the result from the jabber:iq:auth
3542 * <iq/> stanza is returned.
3543 *
3544 * Parameters:
3545 * (XMLElement) elem - The stanza that triggered the callback.
3546 *
3547 * Returns:
3548 * false to remove the handler.
3549 */
3550 _auth2_cb: function (elem)
3551 {
3552 if (elem.getAttribute("type") == "result") {
3553 this.authenticated = true;
3554 this._changeConnectStatus(Strophe.Status.CONNECTED, null);
3555 } else if (elem.getAttribute("type") == "error") {
3556 this._changeConnectStatus(Strophe.Status.AUTHFAIL, null);
3557 this.disconnect(‘authentication failed‘);
3558 }
3559
3560 return false;
3561 },
3562
3563 /** PrivateFunction: _addSysTimedHandler
3564 * _Private_ function to add a system level timed handler.
3565 *
3566 * This function is used to add a Strophe.TimedHandler for the
3567 * library code. System timed handlers are allowed to run before
3568 * authentication is complete.
3569 *
3570 * Parameters:
3571 * (Integer) period - The period of the handler.
3572 * (Function) handler - The callback function.
3573 */
3574 _addSysTimedHandler: function (period, handler)
3575 {
3576 var thand = new Strophe.TimedHandler(period, handler);
3577 thand.user = false;
3578 this.addTimeds.push(thand);
3579 return thand;
3580 },
3581
3582 /** PrivateFunction: _addSysHandler
3583 * _Private_ function to add a system level stanza handler.
3584 *
3585 * This function is used to add a Strophe.Handler for the
3586 * library code. System stanza handlers are allowed to run before
3587 * authentication is complete.
3588 *
3589 * Parameters:
3590 * (Function) handler - The callback function.
3591 * (String) ns - The namespace to match.
3592 * (String) name - The stanza name to match.
3593 * (String) type - The stanza type attribute to match.
3594 * (String) id - The stanza id attribute to match.
3595 */
3596 _addSysHandler: function (handler, ns, name, type, id)
3597 {
3598 var hand = new Strophe.Handler(handler, ns, name, type, id);
3599 hand.user = false;
3600 this.addHandlers.push(hand);
3601 return hand;
3602 },
3603
3604 /** PrivateFunction: _onDisconnectTimeout
3605 * _Private_ timeout handler for handling non-graceful disconnection.
3606 *
3607 * If the graceful disconnect process does not complete within the
3608 * time allotted, this handler finishes the disconnect anyway.
3609 *
3610 * Returns:
3611 * false to remove the handler.
3612 */
3613 _onDisconnectTimeout: function ()
3614 {
3615 Strophe.info("_onDisconnectTimeout was called");
3616
3617 this._proto._onDisconnectTimeout();
3618
3619 // actually disconnect
3620 this._doDisconnect();
3621
3622 return false;
3623 },
3624
3625 /** PrivateFunction: _onIdle
3626 * _Private_ handler to process events during idle cycle.
3627 *
3628 * This handler is called every 100ms to fire timed handlers that
3629 * are ready and keep poll requests going.
3630 */
3631 _onIdle: function ()
3632 {
3633 var i, thand, since, newList;
3634
3635 // add timed handlers scheduled for addition
3636 // NOTE: we add before remove in the case a timed handler is
3637 // added and then deleted before the next _onIdle() call.
3638 while (this.addTimeds.length > 0) {
3639 this.timedHandlers.push(this.addTimeds.pop());
3640 }
3641
3642 // remove timed handlers that have been scheduled for deletion
3643 while (this.removeTimeds.length > 0) {
3644 thand = this.removeTimeds.pop();
3645 i = this.timedHandlers.indexOf(thand);
3646 if (i >= 0) {
3647 this.timedHandlers.splice(i, 1);
3648 }
3649 }
3650
3651 // call ready timed handlers
3652 var now = new Date().getTime();
3653 newList = [];
3654 for (i = 0; i < this.timedHandlers.length; i++) {
3655 thand = this.timedHandlers[i];
3656 if (this.authenticated || !thand.user) {
3657 since = thand.lastCalled + thand.period;
3658 if (since - now <= 0) {
3659 if (thand.run()) {
3660 newList.push(thand);
3661 }
3662 } else {
3663 newList.push(thand);
3664 }
3665 }
3666 }
3667 this.timedHandlers = newList;
3668
3669 clearTimeout(this._idleTimeout);
3670
3671 this._proto._onIdle();
3672
3673 // reactivate the timer only if connected
3674 if (this.connected) {
3675 this._idleTimeout = setTimeout(this._onIdle.bind(this), 100);
3676 }
3677 }
3678 };
3679
3680 /** Class: Strophe.SASLMechanism
3681 *
3682 * encapsulates SASL authentication mechanisms.
3683 *
3684 * User code may override the priority for each mechanism or disable it completely.
3685 * See <priority> for information about changing priority and <test> for informatian on
3686 * how to disable a mechanism.
3687 *
3688 * By default, all mechanisms are enabled and the priorities are
3689 *
3690 * SCRAM-SHA1 - 40
3691 * DIGEST-MD5 - 30
3692 * Plain - 20
3693 */
3694
3695 /**
3696 * PrivateConstructor: Strophe.SASLMechanism
3697 * SASL auth mechanism abstraction.
3698 *
3699 * Parameters:
3700 * (String) name - SASL Mechanism name.
3701 * (Boolean) isClientFirst - If client should send response first without challenge.
3702 * (Number) priority - Priority.
3703 *
3704 * Returns:
3705 * A new Strophe.SASLMechanism object.
3706 */
3707 Strophe.SASLMechanism = function(name, isClientFirst, priority) {
3708 /** PrivateVariable: name
3709 * Mechanism name.
3710 */
3711 this.name = name;
3712 /** PrivateVariable: isClientFirst
3713 * If client sends response without initial server challenge.
3714 */
3715 this.isClientFirst = isClientFirst;
3716 /** Variable: priority
3717 * Determines which <SASLMechanism> is chosen for authentication (Higher is better).
3718 * Users may override this to prioritize mechanisms differently.
3719 *
3720 * In the default configuration the priorities are
3721 *
3722 * SCRAM-SHA1 - 40
3723 * DIGEST-MD5 - 30
3724 * Plain - 20
3725 *
3726 * Example: (This will cause Strophe to choose the mechanism that the server sent first)
3727 *
3728 * > Strophe.SASLMD5.priority = Strophe.SASLSHA1.priority;
3729 *
3730 * See <SASL mechanisms> for a list of available mechanisms.
3731 *
3732 */
3733 this.priority = priority;
3734 };
3735
3736 Strophe.SASLMechanism.prototype = {
3737 /**
3738 * Function: test
3739 * Checks if mechanism able to run.
3740 * To disable a mechanism, make this return false;
3741 *
3742 * To disable plain authentication run
3743 * > Strophe.SASLPlain.test = function() {
3744 * > return false;
3745 * > }
3746 *
3747 * See <SASL mechanisms> for a list of available mechanisms.
3748 *
3749 * Parameters:
3750 * (Strophe.Connection) connection - Target Connection.
3751 *
3752 * Returns:
3753 * (Boolean) If mechanism was able to run.
3754 */
3755 /* jshint unused:false */
3756 test: function(connection) {
3757 return true;
3758 },
3759 /* jshint unused:true */
3760
3761 /** PrivateFunction: onStart
3762 * Called before starting mechanism on some connection.
3763 *
3764 * Parameters:
3765 * (Strophe.Connection) connection - Target Connection.
3766 */
3767 onStart: function(connection)
3768 {
3769 this._connection = connection;
3770 },
3771
3772 /** PrivateFunction: onChallenge
3773 * Called by protocol implementation on incoming challenge. If client is
3774 * first (isClientFirst == true) challenge will be null on the first call.
3775 *
3776 * Parameters:
3777 * (Strophe.Connection) connection - Target Connection.
3778 * (String) challenge - current challenge to handle.
3779 *
3780 * Returns:
3781 * (String) Mechanism response.
3782 */
3783 /* jshint unused:false */
3784 onChallenge: function(connection, challenge) {
3785 throw new Error("You should implement challenge handling!");
3786 },
3787 /* jshint unused:true */
3788
3789 /** PrivateFunction: onFailure
3790 * Protocol informs mechanism implementation about SASL failure.
3791 */
3792 onFailure: function() {
3793 this._connection = null;
3794 },
3795
3796 /** PrivateFunction: onSuccess
3797 * Protocol informs mechanism implementation about SASL success.
3798 */
3799 onSuccess: function() {
3800 this._connection = null;
3801 }
3802 };
3803
3804 /** Constants: SASL mechanisms
3805 * Available authentication mechanisms
3806 *
3807 * Strophe.SASLAnonymous - SASL Anonymous authentication.
3808 * Strophe.SASLPlain - SASL Plain authentication.
3809 * Strophe.SASLMD5 - SASL Digest-MD5 authentication
3810 * Strophe.SASLSHA1 - SASL SCRAM-SHA1 authentication
3811 */
3812
3813 // Building SASL callbacks
3814
3815 /** PrivateConstructor: SASLAnonymous
3816 * SASL Anonymous authentication.
3817 */
3818 Strophe.SASLAnonymous = function() {};
3819
3820 Strophe.SASLAnonymous.prototype = new Strophe.SASLMechanism("ANONYMOUS", false, 10);
3821
3822 Strophe.SASLAnonymous.test = function(connection) {
3823 return connection.authcid === null;
3824 };
3825
3826 Strophe.Connection.prototype.mechanisms[Strophe.SASLAnonymous.prototype.name] = Strophe.SASLAnonymous;
3827
3828 /** PrivateConstructor: SASLPlain
3829 * SASL Plain authentication.
3830 */
3831 Strophe.SASLPlain = function() {};
3832
3833 Strophe.SASLPlain.prototype = new Strophe.SASLMechanism("PLAIN", true, 20);
3834
3835 Strophe.SASLPlain.test = function(connection) {
3836 return connection.authcid !== null;
3837 };
3838
3839 Strophe.SASLPlain.prototype.onChallenge = function(connection) {
3840 var auth_str = connection.authzid;
3841 auth_str = auth_str + "\u0000";
3842 auth_str = auth_str + connection.authcid;
3843 auth_str = auth_str + "\u0000";
3844 auth_str = auth_str + connection.pass;
3845 return auth_str;
3846 };
3847
3848 Strophe.Connection.prototype.mechanisms[Strophe.SASLPlain.prototype.name] = Strophe.SASLPlain;
3849
3850 /** PrivateConstructor: SASLSHA1
3851 * SASL SCRAM SHA 1 authentication.
3852 */
3853 Strophe.SASLSHA1 = function() {};
3854
3855 /* TEST:
3856 * This is a simple example of a SCRAM-SHA-1 authentication exchange
3857 * when the client doesn‘t support channel bindings (username ‘user‘ and
3858 * password ‘pencil‘ are used):
3859 *
3860 * C: n,,n=user,r=fyko+d2lbbFgONRv9qkxdawL
3861 * S: r=fyko+d2lbbFgONRv9qkxdawL3rfcNHYJY1ZVvWVs7j,s=QSXCR+Q6sek8bf92,
3862 * i=4096
3863 * C: c=biws,r=fyko+d2lbbFgONRv9qkxdawL3rfcNHYJY1ZVvWVs7j,
3864 * p=v0X8v3Bz2T0CJGbJQyF0X+HI4Ts=
3865 * S: v=rmF9pqV8S7suAoZWja4dJRkFsKQ=
3866 *
3867 */
3868
3869 Strophe.SASLSHA1.prototype = new Strophe.SASLMechanism("SCRAM-SHA-1", true, 40);
3870
3871 Strophe.SASLSHA1.test = function(connection) {
3872 return connection.authcid !== null;
3873 };
3874
3875 Strophe.SASLSHA1.prototype.onChallenge = function(connection, challenge, test_cnonce) {
3876 var cnonce = test_cnonce || MD5.hexdigest(Math.random() * 1234567890);
3877
3878 var auth_str = "n=" + connection.authcid;
3879 auth_str += ",r=";
3880 auth_str += cnonce;
3881
3882 connection._sasl_data.cnonce = cnonce;
3883 connection._sasl_data["client-first-message-bare"] = auth_str;
3884
3885 auth_str = "n,," + auth_str;
3886
3887 this.onChallenge = function (connection, challenge)
3888 {
3889 var nonce, salt, iter, Hi, U, U_old, i, k;
3890 var clientKey, serverKey, clientSignature;
3891 var responseText = "c=biws,";
3892 var authMessage = connection._sasl_data["client-first-message-bare"] + "," +
3893 challenge + ",";
3894 var cnonce = connection._sasl_data.cnonce;
3895 var attribMatch = /([a-z]+)=([^,]+)(,|$)/;
3896
3897 while (challenge.match(attribMatch)) {
3898 var matches = challenge.match(attribMatch);
3899 challenge = challenge.replace(matches[0], "");
3900 switch (matches[1]) {
3901 case "r":
3902 nonce = matches[2];
3903 break;
3904 case "s":
3905 salt = matches[2];
3906 break;
3907 case "i":
3908 iter = matches[2];
3909 break;
3910 }
3911 }
3912
3913 if (nonce.substr(0, cnonce.length) !== cnonce) {
3914 connection._sasl_data = {};
3915 return connection._sasl_failure_cb();
3916 }
3917
3918 responseText += "r=" + nonce;
3919 authMessage += responseText;
3920
3921 salt = Base64.decode(salt);
3922 salt += "\x00\x00\x00\x01";
3923
3924 Hi = U_old = SHA1.core_hmac_sha1(connection.pass, salt);
3925 for (i = 1; i < iter; i++) {
3926 U = SHA1.core_hmac_sha1(connection.pass, SHA1.binb2str(U_old));
3927 for (k = 0; k < 5; k++) {
3928 Hi[k] ^= U[k];
3929 }
3930 U_old = U;
3931 }
3932 Hi = SHA1.binb2str(Hi);
3933
3934 clientKey = SHA1.core_hmac_sha1(Hi, "Client Key");
3935 serverKey = SHA1.str_hmac_sha1(Hi, "Server Key");
3936 clientSignature = SHA1.core_hmac_sha1(SHA1.str_sha1(SHA1.binb2str(clientKey)), authMessage);
3937 connection._sasl_data["server-signature"] = SHA1.b64_hmac_sha1(serverKey, authMessage);
3938
3939 for (k = 0; k < 5; k++) {
3940 clientKey[k] ^= clientSignature[k];
3941 }
3942
3943 responseText += ",p=" + Base64.encode(SHA1.binb2str(clientKey));
3944
3945 return responseText;
3946 }.bind(this);
3947
3948 return auth_str;
3949 };
3950
3951 Strophe.Connection.prototype.mechanisms[Strophe.SASLSHA1.prototype.name] = Strophe.SASLSHA1;
3952
3953 /** PrivateConstructor: SASLMD5
3954 * SASL DIGEST MD5 authentication.
3955 */
3956 Strophe.SASLMD5 = function() {};
3957
3958 Strophe.SASLMD5.prototype = new Strophe.SASLMechanism("DIGEST-MD5", false, 30);
3959
3960 Strophe.SASLMD5.test = function(connection) {
3961 return connection.authcid !== null;
3962 };
3963
3964 /** PrivateFunction: _quote
3965 * _Private_ utility function to backslash escape and quote strings.
3966 *
3967 * Parameters:
3968 * (String) str - The string to be quoted.
3969 *
3970 * Returns:
3971 * quoted string
3972 */
3973 Strophe.SASLMD5.prototype._quote = function (str)
3974 {
3975 return ‘"‘ + str.replace(/\\/g, "\\\\").replace(/"/g, ‘\\"‘) + ‘"‘;
3976 //" end string workaround for emacs
3977 };
3978
3979
3980 Strophe.SASLMD5.prototype.onChallenge = function(connection, challenge, test_cnonce) {
3981 var attribMatch = /([a-z]+)=("[^"]+"|[^,"]+)(?:,|$)/;
3982 var cnonce = test_cnonce || MD5.hexdigest("" + (Math.random() * 1234567890));
3983 var realm = "";
3984 var host = null;
3985 var nonce = "";
3986 var qop = "";
3987 var matches;
3988
3989 while (challenge.match(attribMatch)) {
3990 matches = challenge.match(attribMatch);
3991 challenge = challenge.replace(matches[0], "");
3992 matches[2] = matches[2].replace(/^"(.+)"$/, "$1");
3993 switch (matches[1]) {
3994 case "realm":
3995 realm = matches[2];
3996 break;
3997 case "nonce":
3998 nonce = matches[2];
3999 break;
4000 case "qop":
4001 qop = matches[2];
4002 break;
4003 case "host":
4004 host = matches[2];
4005 break;
4006 }
4007 }
4008
4009 var digest_uri = connection.servtype + "/" + connection.domain;
4010 if (host !== null) {
4011 digest_uri = digest_uri + "/" + host;
4012 }
4013
4014 var A1 = MD5.hash(connection.authcid +
4015 ":" + realm + ":" + this._connection.pass) +
4016 ":" + nonce + ":" + cnonce;
4017 var A2 = ‘AUTHENTICATE:‘ + digest_uri;
4018
4019 var responseText = "";
4020 responseText += ‘charset=utf-8,‘;
4021 responseText += ‘username=‘ +
4022 this._quote(connection.authcid) + ‘,‘;
4023 responseText += ‘realm=‘ + this._quote(realm) + ‘,‘;
4024 responseText += ‘nonce=‘ + this._quote(nonce) + ‘,‘;
4025 responseText += ‘nc=00000001,‘;
4026 responseText += ‘cnonce=‘ + this._quote(cnonce) + ‘,‘;
4027 responseText += ‘digest-uri=‘ + this._quote(digest_uri) + ‘,‘;
4028 responseText += ‘response=‘ + MD5.hexdigest(MD5.hexdigest(A1) + ":" +
4029 nonce + ":00000001:" +
4030 cnonce + ":auth:" +
4031 MD5.hexdigest(A2)) + ",";
4032 responseText += ‘qop=auth‘;
4033
4034 this.onChallenge = function ()
4035 {
4036 return "";
4037 }.bind(this);
4038
4039 return responseText;
4040 };
4041
4042 Strophe.Connection.prototype.mechanisms[Strophe.SASLMD5.prototype.name] = Strophe.SASLMD5;
4043
4044 return {
4045 Strophe: Strophe,
4046 $build: $build,
4047 $msg: $msg,
4048 $iq: $iq,
4049 $pres: $pres,
4050 SHA1: SHA1,
4051 Base64: Base64,
4052 MD5: MD5,
4053 };
4054 }));
4055
4056 /*
4057 This program is distributed under the terms of the MIT license.
4058 Please see the LICENSE file for details.
4059
4060 Copyright 2006-2008, OGG, LLC
4061 */
4062
4063 /* jshint undef: true, unused: true:, noarg: true, latedef: true */
4064 /* global define, window, setTimeout, clearTimeout, XMLHttpRequest, ActiveXObject, Strophe, $build */
4065
4066 (function (root, factory) {
4067 if (typeof define === ‘function‘ && define.amd) {
4068 define(‘strophe-bosh‘, [‘strophe-core‘], function (core) {
4069 return factory(
4070 core.Strophe,
4071 core.$build
4072 );
4073 });
4074 } else {
4075 // Browser globals
4076 return factory(Strophe, $build);
4077 }
4078 }(this, function (Strophe, $build) {
4079
4080 /** PrivateClass: Strophe.Request
4081 * _Private_ helper class that provides a cross implementation abstraction
4082 * for a BOSH related XMLHttpRequest.
4083 *
4084 * The Strophe.Request class is used internally to encapsulate BOSH request
4085 * information. It is not meant to be used from user‘s code.
4086 */
4087
4088 /** PrivateConstructor: Strophe.Request
4089 * Create and initialize a new Strophe.Request object.
4090 *
4091 * Parameters:
4092 * (XMLElement) elem - The XML data to be sent in the request.
4093 * (Function) func - The function that will be called when the
4094 * XMLHttpRequest readyState changes.
4095 * (Integer) rid - The BOSH rid attribute associated with this request.
4096 * (Integer) sends - The number of times this same request has been
4097 * sent.
4098 */
4099 Strophe.Request = function (elem, func, rid, sends)
4100 {
4101 this.id = ++Strophe._requestId;
4102 this.xmlData = elem;
4103 this.data = Strophe.serialize(elem);
4104 // save original function in case we need to make a new request
4105 // from this one.
4106 this.origFunc = func;
4107 this.func = func;
4108 this.rid = rid;
4109 this.date = NaN;
4110 this.sends = sends || 0;
4111 this.abort = false;
4112 this.dead = null;
4113
4114 this.age = function () {
4115 if (!this.date) { return 0; }
4116 var now = new Date();
4117 return (now - this.date) / 1000;
4118 };
4119 this.timeDead = function () {
4120 if (!this.dead) { return 0; }
4121 var now = new Date();
4122 return (now - this.dead) / 1000;
4123 };
4124 this.xhr = this._newXHR();
4125 };
4126
4127 Strophe.Request.prototype = {
4128 /** PrivateFunction: getResponse
4129 * Get a response from the underlying XMLHttpRequest.
4130 *
4131 * This function attempts to get a response from the request and checks
4132 * for errors.
4133 *
4134 * Throws:
4135 * "parsererror" - A parser error occured.
4136 *
4137 * Returns:
4138 * The DOM element tree of the response.
4139 */
4140 getResponse: function ()
4141 {
4142 var node = null;
4143 if (this.xhr.responseXML && this.xhr.responseXML.documentElement) {
4144 node = this.xhr.responseXML.documentElement;
4145 if (node.tagName == "parsererror") {
4146 Strophe.error("invalid response received");
4147 Strophe.error("responseText: " + this.xhr.responseText);
4148 Strophe.error("responseXML: " +
4149 Strophe.serialize(this.xhr.responseXML));
4150 throw "parsererror";
4151 }
4152 } else if (this.xhr.responseText) {
4153 Strophe.error("invalid response received");
4154 Strophe.error("responseText: " + this.xhr.responseText);
4155 Strophe.error("responseXML: " +
4156 Strophe.serialize(this.xhr.responseXML));
4157 }
4158
4159 return node;
4160 },
4161
4162 /** PrivateFunction: _newXHR
4163 * _Private_ helper function to create XMLHttpRequests.
4164 *
4165 * This function creates XMLHttpRequests across all implementations.
4166 *
4167 * Returns:
4168 * A new XMLHttpRequest.
4169 */
4170 _newXHR: function ()
4171 {
4172 var xhr = null;
4173 if (window.XMLHttpRequest) {
4174 xhr = new XMLHttpRequest();
4175 if (xhr.overrideMimeType) {
4176 xhr.overrideMimeType("text/xml; charset=utf-8");
4177 }
4178 } else if (window.ActiveXObject) {
4179 xhr = new ActiveXObject("Microsoft.XMLHTTP");
4180 }
4181
4182 // use Function.bind() to prepend ourselves as an argument
4183 xhr.onreadystatechange = this.func.bind(null, this);
4184
4185 return xhr;
4186 }
4187 };
4188
4189 /** Class: Strophe.Bosh
4190 * _Private_ helper class that handles BOSH Connections
4191 *
4192 * The Strophe.Bosh class is used internally by Strophe.Connection
4193 * to encapsulate BOSH sessions. It is not meant to be used from user‘s code.
4194 */
4195
4196 /** File: bosh.js
4197 * A JavaScript library to enable BOSH in Strophejs.
4198 *
4199 * this library uses Bidirectional-streams Over Synchronous HTTP (BOSH)
4200 * to emulate a persistent, stateful, two-way connection to an XMPP server.
4201 * More information on BOSH can be found in XEP 124.
4202 */
4203
4204 /** PrivateConstructor: Strophe.Bosh
4205 * Create and initialize a Strophe.Bosh object.
4206 *
4207 * Parameters:
4208 * (Strophe.Connection) connection - The Strophe.Connection that will use BOSH.
4209 *
4210 * Returns:
4211 * A new Strophe.Bosh object.
4212 */
4213 Strophe.Bosh = function(connection) {
4214 this._conn = connection;
4215 /* request id for body tags */
4216 this.rid = Math.floor(Math.random() * 4294967295);
4217 /* The current session ID. */
4218 this.sid = null;
4219
4220 // default BOSH values
4221 this.hold = 1;
4222 this.wait = 60;
4223 this.window = 5;
4224 this.errors = 0;
4225
4226 this._requests = [];
4227 };
4228
4229 Strophe.Bosh.prototype = {
4230 /** Variable: strip
4231 *
4232 * BOSH-Connections will have all stanzas wrapped in a <body> tag when
4233 * passed to <Strophe.Connection.xmlInput> or <Strophe.Connection.xmlOutput>.
4234 * To strip this tag, User code can set <Strophe.Bosh.strip> to "body":
4235 *
4236 * > Strophe.Bosh.prototype.strip = "body";
4237 *
4238 * This will enable stripping of the body tag in both
4239 * <Strophe.Connection.xmlInput> and <Strophe.Connection.xmlOutput>.
4240 */
4241 strip: null,
4242
4243 /** PrivateFunction: _buildBody
4244 * _Private_ helper function to generate the <body/> wrapper for BOSH.
4245 *
4246 * Returns:
4247 * A Strophe.Builder with a <body/> element.
4248 */
4249 _buildBody: function ()
4250 {
4251 var bodyWrap = $build(‘body‘, {
4252 rid: this.rid++,
4253 xmlns: Strophe.NS.HTTPBIND
4254 });
4255 if (this.sid !== null) {
4256 bodyWrap.attrs({sid: this.sid});
4257 }
4258 if (this._conn.options.keepalive) {
4259 this._cacheSession();
4260 }
4261 return bodyWrap;
4262 },
4263
4264 /** PrivateFunction: _reset
4265 * Reset the connection.
4266 *
4267 * This function is called by the reset function of the Strophe Connection
4268 */
4269 _reset: function ()
4270 {
4271 this.rid = Math.floor(Math.random() * 4294967295);
4272 this.sid = null;
4273 this.errors = 0;
4274 window.sessionStorage.removeItem(‘strophe-bosh-session‘);
4275 },
4276
4277 /** PrivateFunction: _connect
4278 * _Private_ function that initializes the BOSH connection.
4279 *
4280 * Creates and sends the Request that initializes the BOSH connection.
4281 */
4282 _connect: function (wait, hold, route)
4283 {
4284 this.wait = wait || this.wait;
4285 this.hold = hold || this.hold;
4286 this.errors = 0;
4287
4288 // build the body tag
4289 var body = this._buildBody().attrs({
4290 to: this._conn.domain,
4291 "xml:lang": "en",
4292 wait: this.wait,
4293 hold: this.hold,
4294 content: "text/xml; charset=utf-8",
4295 ver: "1.6",
4296 "xmpp:version": "1.0",
4297 "xmlns:xmpp": Strophe.NS.BOSH
4298 });
4299
4300 if(route){
4301 body.attrs({
4302 route: route
4303 });
4304 }
4305
4306 var _connect_cb = this._conn._connect_cb;
4307
4308 this._requests.push(
4309 new Strophe.Request(body.tree(),
4310 this._onRequestStateChange.bind(
4311 this, _connect_cb.bind(this._conn)),
4312 body.tree().getAttribute("rid")));
4313 this._throttledRequestHandler();
4314 },
4315
4316 /** PrivateFunction: _attach
4317 * Attach to an already created and authenticated BOSH session.
4318 *
4319 * This function is provided to allow Strophe to attach to BOSH
4320 * sessions which have been created externally, perhaps by a Web
4321 * application. This is often used to support auto-login type features
4322 * without putting user credentials into the page.
4323 *
4324 * Parameters:
4325 * (String) jid - The full JID that is bound by the session.
4326 * (String) sid - The SID of the BOSH session.
4327 * (String) rid - The current RID of the BOSH session. This RID
4328 * will be used by the next request.
4329 * (Function) callback The connect callback function.
4330 * (Integer) wait - The optional HTTPBIND wait value. This is the
4331 * time the server will wait before returning an empty result for
4332 * a request. The default setting of 60 seconds is recommended.
4333 * Other settings will require tweaks to the Strophe.TIMEOUT value.
4334 * (Integer) hold - The optional HTTPBIND hold value. This is the
4335 * number of connections the server will hold at one time. This
4336 * should almost always be set to 1 (the default).
4337 * (Integer) wind - The optional HTTBIND window value. This is the
4338 * allowed range of request ids that are valid. The default is 5.
4339 */
4340 _attach: function (jid, sid, rid, callback, wait, hold, wind)
4341 {
4342 this._conn.jid = jid;
4343 this.sid = sid;
4344 this.rid = rid;
4345
4346 this._conn.connect_callback = callback;
4347
4348 this._conn.domain = Strophe.getDomainFromJid(this._conn.jid);
4349
4350 this._conn.authenticated = true;
4351 this._conn.connected = true;
4352
4353 this.wait = wait || this.wait;
4354 this.hold = hold || this.hold;
4355 this.window = wind || this.window;
4356
4357 this._conn._changeConnectStatus(Strophe.Status.ATTACHED, null);
4358 },
4359
4360 /** PrivateFunction: _restore
4361 * Attempt to restore a cached BOSH session
4362 *
4363 * Parameters:
4364 * (String) jid - The full JID that is bound by the session.
4365 * This parameter is optional but recommended, specifically in cases
4366 * where prebinded BOSH sessions are used where it‘s important to know
4367 * that the right session is being restored.
4368 * (Function) callback The connect callback function.
4369 * (Integer) wait - The optional HTTPBIND wait value. This is the
4370 * time the server will wait before returning an empty result for
4371 * a request. The default setting of 60 seconds is recommended.
4372 * Other settings will require tweaks to the Strophe.TIMEOUT value.
4373 * (Integer) hold - The optional HTTPBIND hold value. This is the
4374 * number of connections the server will hold at one time. This
4375 * should almost always be set to 1 (the default).
4376 * (Integer) wind - The optional HTTBIND window value. This is the
4377 * allowed range of request ids that are valid. The default is 5.
4378 */
4379 _restore: function (jid, callback, wait, hold, wind)
4380 {
4381 var session = JSON.parse(window.sessionStorage.getItem(‘strophe-bosh-session‘));
4382 if (typeof session !== "undefined" &&
4383 session !== null &&
4384 session.rid &&
4385 session.sid &&
4386 session.jid &&
4387 (typeof jid === "undefined" || Strophe.getBareJidFromJid(session.jid) == Strophe.getBareJidFromJid(jid)))
4388 {
4389 this._conn.restored = true;
4390 this._attach(session.jid, session.sid, session.rid, callback, wait, hold, wind);
4391 } else {
4392 throw { name: "StropheSessionError", message: "_restore: no restoreable session." };
4393 }
4394 },
4395
4396 /** PrivateFunction: _cacheSession
4397 * _Private_ handler for the beforeunload event.
4398 *
4399 * This handler is used to process the Bosh-part of the initial request.
4400 * Parameters:
4401 * (Strophe.Request) bodyWrap - The received stanza.
4402 */
4403 _cacheSession: function ()
4404 {
4405 if (this._conn.authenticated) {
4406 if (this._conn.jid && this.rid && this.sid) {
4407 window.sessionStorage.setItem(‘strophe-bosh-session‘, JSON.stringify({
4408 ‘jid‘: this._conn.jid,
4409 ‘rid‘: this.rid,
4410 ‘sid‘: this.sid
4411 }));
4412 }
4413 } else {
4414 window.sessionStorage.removeItem(‘strophe-bosh-session‘);
4415 }
4416 },
4417
4418 /** PrivateFunction: _connect_cb
4419 * _Private_ handler for initial connection request.
4420 *
4421 * This handler is used to process the Bosh-part of the initial request.
4422 * Parameters:
4423 * (Strophe.Request) bodyWrap - The received stanza.
4424 */
4425 _connect_cb: function (bodyWrap)
4426 {
4427 var typ = bodyWrap.getAttribute("type");
4428 var cond, conflict;
4429 if (typ !== null && typ == "terminate") {
4430 // an error occurred
4431 cond = bodyWrap.getAttribute("condition");
4432 Strophe.error("BOSH-Connection failed: " + cond);
4433 conflict = bodyWrap.getElementsByTagName("conflict");
4434 if (cond !== null) {
4435 if (cond == "remote-stream-error" && conflict.length > 0) {
4436 cond = "conflict";
4437 }
4438 this._conn._changeConnectStatus(Strophe.Status.CONNFAIL, cond);
4439 } else {
4440 this._conn._changeConnectStatus(Strophe.Status.CONNFAIL, "unknown");
4441 }
4442 this._conn._doDisconnect(cond);
4443 return Strophe.Status.CONNFAIL;
4444 }
4445
4446 // check to make sure we don‘t overwrite these if _connect_cb is
4447 // called multiple times in the case of missing stream:features
4448 if (!this.sid) {
4449 this.sid = bodyWrap.getAttribute("sid");
4450 }
4451 var wind = bodyWrap.getAttribute(‘requests‘);
4452 if (wind) { this.window = parseInt(wind, 10); }
4453 var hold = bodyWrap.getAttribute(‘hold‘);
4454 if (hold) { this.hold = parseInt(hold, 10); }
4455 var wait = bodyWrap.getAttribute(‘wait‘);
4456 if (wait) { this.wait = parseInt(wait, 10); }
4457 },
4458
4459 /** PrivateFunction: _disconnect
4460 * _Private_ part of Connection.disconnect for Bosh
4461 *
4462 * Parameters:
4463 * (Request) pres - This stanza will be sent before disconnecting.
4464 */
4465 _disconnect: function (pres)
4466 {
4467 this._sendTerminate(pres);
4468 },
4469
4470 /** PrivateFunction: _doDisconnect
4471 * _Private_ function to disconnect.
4472 *
4473 * Resets the SID and RID.
4474 */
4475 _doDisconnect: function ()
4476 {
4477 this.sid = null;
4478 this.rid = Math.floor(Math.random() * 4294967295);
4479 window.sessionStorage.removeItem(‘strophe-bosh-session‘);
4480 },
4481
4482 /** PrivateFunction: _emptyQueue
4483 * _Private_ function to check if the Request queue is empty.
4484 *
4485 * Returns:
4486 * True, if there are no Requests queued, False otherwise.
4487 */
4488 _emptyQueue: function ()
4489 {
4490 return this._requests.length === 0;
4491 },
4492
4493 /** PrivateFunction: _hitError
4494 * _Private_ function to handle the error count.
4495 *
4496 * Requests are resent automatically until their error count reaches
4497 * 5. Each time an error is encountered, this function is called to
4498 * increment the count and disconnect if the count is too high.
4499 *
4500 * Parameters:
4501 * (Integer) reqStatus - The request status.
4502 */
4503 _hitError: function (reqStatus)
4504 {
4505 this.errors++;
4506 Strophe.warn("request errored, status: " + reqStatus +
4507 ", number of errors: " + this.errors);
4508 if (this.errors > 4) {
4509 this._conn._onDisconnectTimeout();
4510 }
4511 },
4512
4513 /** PrivateFunction: _no_auth_received
4514 *
4515 * Called on stream start/restart when no stream:features
4516 * has been received and sends a blank poll request.
4517 */
4518 _no_auth_received: function (_callback)
4519 {
4520 if (_callback) {
4521 _callback = _callback.bind(this._conn);
4522 } else {
4523 _callback = this._conn._connect_cb.bind(this._conn);
4524 }
4525 var body = this._buildBody();
4526 this._requests.push(
4527 new Strophe.Request(body.tree(),
4528 this._onRequestStateChange.bind(
4529 this, _callback.bind(this._conn)),
4530 body.tree().getAttribute("rid")));
4531 this._throttledRequestHandler();
4532 },
4533
4534 /** PrivateFunction: _onDisconnectTimeout
4535 * _Private_ timeout handler for handling non-graceful disconnection.
4536 *
4537 * Cancels all remaining Requests and clears the queue.
4538 */
4539 _onDisconnectTimeout: function () {
4540 this._abortAllRequests();
4541 },
4542
4543 /** PrivateFunction: _abortAllRequests
4544 * _Private_ helper function that makes sure all pending requests are aborted.
4545 */
4546 _abortAllRequests: function _abortAllRequests() {
4547 var req;
4548 while (this._requests.length > 0) {
4549 req = this._requests.pop();
4550 req.abort = true;
4551 req.xhr.abort();
4552 // jslint complains, but this is fine. setting to empty func
4553 // is necessary for IE6
4554 req.xhr.onreadystatechange = function () {}; // jshint ignore:line
4555 }
4556 },
4557
4558 /** PrivateFunction: _onIdle
4559 * _Private_ handler called by Strophe.Connection._onIdle
4560 *
4561 * Sends all queued Requests or polls with empty Request if there are none.
4562 */
4563 _onIdle: function () {
4564 var data = this._conn._data;
4565
4566 // if no requests are in progress, poll
4567 if (this._conn.authenticated && this._requests.length === 0 &&
4568 data.length === 0 && !this._conn.disconnecting) {
4569 Strophe.info("no requests during idle cycle, sending " +
4570 "blank request");
4571 data.push(null);
4572 }
4573
4574 if (this._conn.paused) {
4575 return;
4576 }
4577
4578 if (this._requests.length < 2 && data.length > 0) {
4579 var body = this._buildBody();
4580 for (var i = 0; i < data.length; i++) {
4581 if (data[i] !== null) {
4582 if (data[i] === "restart") {
4583 body.attrs({
4584 to: this._conn.domain,
4585 "xml:lang": "en",
4586 "xmpp:restart": "true",
4587 "xmlns:xmpp": Strophe.NS.BOSH
4588 });
4589 } else {
4590 body.cnode(data[i]).up();
4591 }
4592 }
4593 }
4594 delete this._conn._data;
4595 this._conn._data = [];
4596 this._requests.push(
4597 new Strophe.Request(body.tree(),
4598 this._onRequestStateChange.bind(
4599 this, this._conn._dataRecv.bind(this._conn)),
4600 body.tree().getAttribute("rid")));
4601 this._throttledRequestHandler();
4602 }
4603
4604 if (this._requests.length > 0) {
4605 var time_elapsed = this._requests[0].age();
4606 if (this._requests[0].dead !== null) {
4607 if (this._requests[0].timeDead() >
4608 Math.floor(Strophe.SECONDARY_TIMEOUT * this.wait)) {
4609 this._throttledRequestHandler();
4610 }
4611 }
4612
4613 if (time_elapsed > Math.floor(Strophe.TIMEOUT * this.wait)) {
4614 Strophe.warn("Request " +
4615 this._requests[0].id +
4616 " timed out, over " + Math.floor(Strophe.TIMEOUT * this.wait) +
4617 " seconds since last activity");
4618 this._throttledRequestHandler();
4619 }
4620 }
4621 },
4622
4623 /** PrivateFunction: _onRequestStateChange
4624 * _Private_ handler for Strophe.Request state changes.
4625 *
4626 * This function is called when the XMLHttpRequest readyState changes.
4627 * It contains a lot of error handling logic for the many ways that
4628 * requests can fail, and calls the request callback when requests
4629 * succeed.
4630 *
4631 * Parameters:
4632 * (Function) func - The handler for the request.
4633 * (Strophe.Request) req - The request that is changing readyState.
4634 */
4635 _onRequestStateChange: function (func, req)
4636 {
4637 Strophe.debug("request id " + req.id +
4638 "." + req.sends + " state changed to " +
4639 req.xhr.readyState);
4640
4641 if (req.abort) {
4642 req.abort = false;
4643 return;
4644 }
4645
4646 // request complete
4647 var reqStatus;
4648 if (req.xhr.readyState == 4) {
4649 reqStatus = 0;
4650 try {
4651 reqStatus = req.xhr.status;
4652 } catch (e) {
4653 // ignore errors from undefined status attribute. works
4654 // around a browser bug
4655 }
4656
4657 if (typeof(reqStatus) == "undefined") {
4658 reqStatus = 0;
4659 }
4660
4661 if (this.disconnecting) {
4662 if (reqStatus >= 400) {
4663 this._hitError(reqStatus);
4664 return;
4665 }
4666 }
4667
4668 var reqIs0 = (this._requests[0] == req);
4669 var reqIs1 = (this._requests[1] == req);
4670
4671 if ((reqStatus > 0 && reqStatus < 500) || req.sends > 5) {
4672 // remove from internal queue
4673 this._removeRequest(req);
4674 Strophe.debug("request id " +
4675 req.id +
4676 " should now be removed");
4677 }
4678
4679 // request succeeded
4680 if (reqStatus == 200) {
4681 // if request 1 finished, or request 0 finished and request
4682 // 1 is over Strophe.SECONDARY_TIMEOUT seconds old, we need to
4683 // restart the other - both will be in the first spot, as the
4684 // completed request has been removed from the queue already
4685 if (reqIs1 ||
4686 (reqIs0 && this._requests.length > 0 &&
4687 this._requests[0].age() > Math.floor(Strophe.SECONDARY_TIMEOUT * this.wait))) {
4688 this._restartRequest(0);
4689 }
4690 // call handler
4691 Strophe.debug("request id " +
4692 req.id + "." +
4693 req.sends + " got 200");
4694 func(req);
4695 this.errors = 0;
4696 } else {
4697 Strophe.error("request id " +
4698 req.id + "." +
4699 req.sends + " error " + reqStatus +
4700 " happened");
4701 if (reqStatus === 0 ||
4702 (reqStatus >= 400 && reqStatus < 600) ||
4703 reqStatus >= 12000) {
4704 this._hitError(reqStatus);
4705 if (reqStatus >= 400 && reqStatus < 500) {
4706 this._conn._changeConnectStatus(Strophe.Status.DISCONNECTING, null);
4707 this._conn._doDisconnect();
4708 }
4709 }
4710 }
4711
4712 if (!((reqStatus > 0 && reqStatus < 500) ||
4713 req.sends > 5)) {
4714 this._throttledRequestHandler();
4715 }
4716 }
4717 },
4718
4719 /** PrivateFunction: _processRequest
4720 * _Private_ function to process a request in the queue.
4721 *
4722 * This function takes requests off the queue and sends them and
4723 * restarts dead requests.
4724 *
4725 * Parameters:
4726 * (Integer) i - The index of the request in the queue.
4727 */
4728 _processRequest: function (i)
4729 {
4730 var self = this;
4731 var req = this._requests[i];
4732 var reqStatus = -1;
4733
4734 try {
4735 if (req.xhr.readyState == 4) {
4736 reqStatus = req.xhr.status;
4737 }
4738 } catch (e) {
4739 Strophe.error("caught an error in _requests[" + i +
4740 "], reqStatus: " + reqStatus);
4741 }
4742
4743 if (typeof(reqStatus) == "undefined") {
4744 reqStatus = -1;
4745 }
4746
4747 // make sure we limit the number of retries
4748 if (req.sends > this._conn.maxRetries) {
4749 this._conn._onDisconnectTimeout();
4750 return;
4751 }
4752
4753 var time_elapsed = req.age();
4754 var primaryTimeout = (!isNaN(time_elapsed) &&
4755 time_elapsed > Math.floor(Strophe.TIMEOUT * this.wait));
4756 var secondaryTimeout = (req.dead !== null &&
4757 req.timeDead() > Math.floor(Strophe.SECONDARY_TIMEOUT * this.wait));
4758 var requestCompletedWithServerError = (req.xhr.readyState == 4 &&
4759 (reqStatus < 1 ||
4760 reqStatus >= 500));
4761 if (primaryTimeout || secondaryTimeout ||
4762 requestCompletedWithServerError) {
4763 if (secondaryTimeout) {
4764 Strophe.error("Request " +
4765 this._requests[i].id +
4766 " timed out (secondary), restarting");
4767 }
4768 req.abort = true;
4769 req.xhr.abort();
4770 // setting to null fails on IE6, so set to empty function
4771 req.xhr.onreadystatechange = function () {};
4772 this._requests[i] = new Strophe.Request(req.xmlData,
4773 req.origFunc,
4774 req.rid,
4775 req.sends);
4776 req = this._requests[i];
4777 }
4778
4779 if (req.xhr.readyState === 0) {
4780 Strophe.debug("request id " + req.id +
4781 "." + req.sends + " posting");
4782
4783 try {
4784 req.xhr.open("POST", this._conn.service, this._conn.options.sync ? false : true);
4785 req.xhr.setRequestHeader("Content-Type", "text/xml; charset=utf-8");
4786 } catch (e2) {
4787 Strophe.error("XHR open failed.");
4788 if (!this._conn.connected) {
4789 this._conn._changeConnectStatus(Strophe.Status.CONNFAIL,
4790 "bad-service");
4791 }
4792 this._conn.disconnect();
4793 return;
4794 }
4795
4796 // Fires the XHR request -- may be invoked immediately
4797 // or on a gradually expanding retry window for reconnects
4798 var sendFunc = function () {
4799 req.date = new Date();
4800 if (self._conn.options.customHeaders){
4801 var headers = self._conn.options.customHeaders;
4802 for (var header in headers) {
4803 if (headers.hasOwnProperty(header)) {
4804 req.xhr.setRequestHeader(header, headers[header]);
4805 }
4806 }
4807 }
4808 req.xhr.send(req.data);
4809 };
4810
4811 // Implement progressive backoff for reconnects --
4812 // First retry (send == 1) should also be instantaneous
4813 if (req.sends > 1) {
4814 // Using a cube of the retry number creates a nicely
4815 // expanding retry window
4816 var backoff = Math.min(Math.floor(Strophe.TIMEOUT * this.wait),
4817 Math.pow(req.sends, 3)) * 1000;
4818 setTimeout(sendFunc, backoff);
4819 } else {
4820 sendFunc();
4821 }
4822
4823 req.sends++;
4824
4825 if (this._conn.xmlOutput !== Strophe.Connection.prototype.xmlOutput) {
4826 if (req.xmlData.nodeName === this.strip && req.xmlData.childNodes.length) {
4827 this._conn.xmlOutput(req.xmlData.childNodes[0]);
4828 } else {
4829 this._conn.xmlOutput(req.xmlData);
4830 }
4831 }
4832 if (this._conn.rawOutput !== Strophe.Connection.prototype.rawOutput) {
4833 this._conn.rawOutput(req.data);
4834 }
4835 } else {
4836 Strophe.debug("_processRequest: " +
4837 (i === 0 ? "first" : "second") +
4838 " request has readyState of " +
4839 req.xhr.readyState);
4840 }
4841 },
4842
4843 /** PrivateFunction: _removeRequest
4844 * _Private_ function to remove a request from the queue.
4845 *
4846 * Parameters:
4847 * (Strophe.Request) req - The request to remove.
4848 */
4849 _removeRequest: function (req)
4850 {
4851 Strophe.debug("removing request");
4852
4853 var i;
4854 for (i = this._requests.length - 1; i >= 0; i--) {
4855 if (req == this._requests[i]) {
4856 this._requests.splice(i, 1);
4857 }
4858 }
4859
4860 // IE6 fails on setting to null, so set to empty function
4861 req.xhr.onreadystatechange = function () {};
4862
4863 this._throttledRequestHandler();
4864 },
4865
4866 /** PrivateFunction: _restartRequest
4867 * _Private_ function to restart a request that is presumed dead.
4868 *
4869 * Parameters:
4870 * (Integer) i - The index of the request in the queue.
4871 */
4872 _restartRequest: function (i)
4873 {
4874 var req = this._requests[i];
4875 if (req.dead === null) {
4876 req.dead = new Date();
4877 }
4878
4879 this._processRequest(i);
4880 },
4881
4882 /** PrivateFunction: _reqToData
4883 * _Private_ function to get a stanza out of a request.
4884 *
4885 * Tries to extract a stanza out of a Request Object.
4886 * When this fails the current connection will be disconnected.
4887 *
4888 * Parameters:
4889 * (Object) req - The Request.
4890 *
4891 * Returns:
4892 * The stanza that was passed.
4893 */
4894 _reqToData: function (req)
4895 {
4896 try {
4897 return req.getResponse();
4898 } catch (e) {
4899 if (e != "parsererror") { throw e; }
4900 this._conn.disconnect("strophe-parsererror");
4901 }
4902 },
4903
4904 /** PrivateFunction: _sendTerminate
4905 * _Private_ function to send initial disconnect sequence.
4906 *
4907 * This is the first step in a graceful disconnect. It sends
4908 * the BOSH server a terminate body and includes an unavailable
4909 * presence if authentication has completed.
4910 */
4911 _sendTerminate: function (pres)
4912 {
4913 Strophe.info("_sendTerminate was called");
4914 var body = this._buildBody().attrs({type: "terminate"});
4915
4916 if (pres) {
4917 body.cnode(pres.tree());
4918 }
4919
4920 var req = new Strophe.Request(body.tree(),
4921 this._onRequestStateChange.bind(
4922 this, this._conn._dataRecv.bind(this._conn)),
4923 body.tree().getAttribute("rid"));
4924
4925 this._requests.push(req);
4926 this._throttledRequestHandler();
4927 },
4928
4929 /** PrivateFunction: _send
4930 * _Private_ part of the Connection.send function for BOSH
4931 *
4932 * Just triggers the RequestHandler to send the messages that are in the queue
4933 */
4934 _send: function () {
4935 clearTimeout(this._conn._idleTimeout);
4936 this._throttledRequestHandler();
4937 this._conn._idleTimeout = setTimeout(this._conn._onIdle.bind(this._conn), 100);
4938 },
4939
4940 /** PrivateFunction: _sendRestart
4941 *
4942 * Send an xmpp:restart stanza.
4943 */
4944 _sendRestart: function ()
4945 {
4946 this._throttledRequestHandler();
4947 clearTimeout(this._conn._idleTimeout);
4948 },
4949
4950 /** PrivateFunction: _throttledRequestHandler
4951 * _Private_ function to throttle requests to the connection window.
4952 *
4953 * This function makes sure we don‘t send requests so fast that the
4954 * request ids overflow the connection window in the case that one
4955 * request died.
4956 */
4957 _throttledRequestHandler: function ()
4958 {
4959 if (!this._requests) {
4960 Strophe.debug("_throttledRequestHandler called with " +
4961 "undefined requests");
4962 } else {
4963 Strophe.debug("_throttledRequestHandler called with " +
4964 this._requests.length + " requests");
4965 }
4966
4967 if (!this._requests || this._requests.length === 0) {
4968 return;
4969 }
4970
4971 if (this._requests.length > 0) {
4972 this._processRequest(0);
4973 }
4974
4975 if (this._requests.length > 1 &&
4976 Math.abs(this._requests[0].rid -
4977 this._requests[1].rid) < this.window) {
4978 this._processRequest(1);
4979 }
4980 }
4981 };
4982 return Strophe;
4983 }));
4984
4985 /*
4986 This program is distributed under the terms of the MIT license.
4987 Please see the LICENSE file for details.
4988
4989 Copyright 2006-2008, OGG, LLC
4990 */
4991
4992 /* jshint undef: true, unused: true:, noarg: true, latedef: true */
4993 /* global define, window, clearTimeout, WebSocket, DOMParser, Strophe, $build */
4994
4995 (function (root, factory) {
4996 if (typeof define === ‘function‘ && define.amd) {
4997 define(‘strophe-websocket‘, [‘strophe-core‘], function (core) {
4998 return factory(
4999 core.Strophe,
5000 core.$build
5001 );
5002 });
5003 } else {
5004 // Browser globals
5005 return factory(Strophe, $build);
5006 }
5007 }(this, function (Strophe, $build) {
5008
5009 /** Class: Strophe.WebSocket
5010 * _Private_ helper class that handles WebSocket Connections
5011 *
5012 * The Strophe.WebSocket class is used internally by Strophe.Connection
5013 * to encapsulate WebSocket sessions. It is not meant to be used from user‘s code.
5014 */
5015
5016 /** File: websocket.js
5017 * A JavaScript library to enable XMPP over Websocket in Strophejs.
5018 *
5019 * This file implements XMPP over WebSockets for Strophejs.
5020 * If a Connection is established with a Websocket url (ws://...)
5021 * Strophe will use WebSockets.
5022 * For more information on XMPP-over-WebSocket see RFC 7395:
5023 * http://tools.ietf.org/html/rfc7395
5024 *
5025 * WebSocket support implemented by Andreas Guth ([email protected])
5026 */
5027
5028 /** PrivateConstructor: Strophe.Websocket
5029 * Create and initialize a Strophe.WebSocket object.
5030 * Currently only sets the connection Object.
5031 *
5032 * Parameters:
5033 * (Strophe.Connection) connection - The Strophe.Connection that will use WebSockets.
5034 *
5035 * Returns:
5036 * A new Strophe.WebSocket object.
5037 */
5038 Strophe.Websocket = function(connection) {
5039 alert(window.location.host);
5040 this._conn = connection;
5041 this.strip = "wrapper";
5042
5043 var service = connection.service;
5044 if (service.indexOf("ws:") !== 0 && service.indexOf("wss:") !== 0) {
5045 // If the service is not an absolute URL, assume it is a path and put the absolute
5046 // URL together from options, current URL and the path.
5047 var new_service = "";
5048
5049 if (connection.options.protocol === "ws" && window.location.protocol !== "https:") {
5050 new_service += "ws";
5051 } else {
5052 new_service += "wss";
5053 }
5054
5055 new_service += "://" + window.location.host;
5056
5057 if (service.indexOf("/") !== 0) {
5058 new_service += window.location.pathname + service;
5059 } else {
5060 new_service += service;
5061 }
5062
5063 connection.service = new_service;
5064 }
5065 };
5066
5067 Strophe.Websocket.prototype = {
5068 /** PrivateFunction: _buildStream
5069 * _Private_ helper function to generate the <stream> start tag for WebSockets
5070 *
5071 * Returns:
5072 * A Strophe.Builder with a <stream> element.
5073 */
5074 _buildStream: function ()
5075 {
5076 return $build("open", {
5077 "xmlns": Strophe.NS.FRAMING,
5078 "to": this._conn.domain,
5079 "version": ‘1.0‘
5080 });
5081 },
5082
5083 /** PrivateFunction: _check_streamerror
5084 * _Private_ checks a message for stream:error
5085 *
5086 * Parameters:
5087 * (Strophe.Request) bodyWrap - The received stanza.
5088 * connectstatus - The ConnectStatus that will be set on error.
5089 * Returns:
5090 * true if there was a streamerror, false otherwise.
5091 */
5092 _check_streamerror: function (bodyWrap, connectstatus) {
5093 var errors;
5094 if (bodyWrap.getElementsByTagNameNS) {
5095 errors = bodyWrap.getElementsByTagNameNS(Strophe.NS.STREAM, "error");
5096 } else {
5097 errors = bodyWrap.getElementsByTagName("stream:error");
5098 }
5099 if (errors.length === 0) {
5100 return false;
5101 }
5102 var error = errors[0];
5103
5104 var condition = "";
5105 var text = "";
5106
5107 var ns = "urn:ietf:params:xml:ns:xmpp-streams";
5108 for (var i = 0; i < error.childNodes.length; i++) {
5109 var e = error.childNodes[i];
5110 if (e.getAttribute("xmlns") !== ns) {
5111 break;
5112 } if (e.nodeName === "text") {
5113 text = e.textContent;
5114 } else {
5115 condition = e.nodeName;
5116 }
5117 }
5118
5119 var errorString = "WebSocket stream error: ";
5120
5121 if (condition) {
5122 errorString += condition;
5123 } else {
5124 errorString += "unknown";
5125 }
5126
5127 if (text) {
5128 errorString += " - " + condition;
5129 }
5130
5131 Strophe.error(errorString);
5132
5133 // close the connection on stream_error
5134 this._conn._changeConnectStatus(connectstatus, condition);
5135 this._conn._doDisconnect();
5136 return true;
5137 },
5138
5139 /** PrivateFunction: _reset
5140 * Reset the connection.
5141 *
5142 * This function is called by the reset function of the Strophe Connection.
5143 * Is not needed by WebSockets.
5144 */
5145 _reset: function ()
5146 {
5147 return;
5148 },
5149
5150 /** PrivateFunction: _connect
5151 * _Private_ function called by Strophe.Connection.connect
5152 *
5153 * Creates a WebSocket for a connection and assigns Callbacks to it.
5154 * Does nothing if there already is a WebSocket.
5155 */
5156 _connect: function () {
5157 // Ensure that there is no open WebSocket from a previous Connection.
5158 this._closeSocket();
5159
5160 // Create the new WobSocket
5161 this.socket = new WebSocket(this._conn.service, "xmpp");
5162 this.socket.onopen = this._onOpen.bind(this);
5163 this.socket.onerror = this._onError.bind(this);
5164 this.socket.onclose = this._onClose.bind(this);
5165 this.socket.onmessage = this._connect_cb_wrapper.bind(this);
5166 },
5167
5168 /** PrivateFunction: _connect_cb
5169 * _Private_ function called by Strophe.Connection._connect_cb
5170 *
5171 * checks for stream:error
5172 *
5173 * Parameters:
5174 * (Strophe.Request) bodyWrap - The received stanza.
5175 */
5176 _connect_cb: function(bodyWrap) {
5177 var error = this._check_streamerror(bodyWrap, Strophe.Status.CONNFAIL);
5178 if (error) {
5179 return Strophe.Status.CONNFAIL;
5180 }
5181 },
5182
5183 /** PrivateFunction: _handleStreamStart
5184 * _Private_ function that checks the opening <open /> tag for errors.
5185 *
5186 * Disconnects if there is an error and returns false, true otherwise.
5187 *
5188 * Parameters:
5189 * (Node) message - Stanza containing the <open /> tag.
5190 */
5191 _handleStreamStart: function(message) {
5192 var error = false;
5193
5194 // Check for errors in the <open /> tag
5195 var ns = message.getAttribute("xmlns");
5196 if (typeof ns !== "string") {
5197 error = "Missing xmlns in <open />";
5198 } else if (ns !== Strophe.NS.FRAMING) {
5199 error = "Wrong xmlns in <open />: " + ns;
5200 }
5201
5202 var ver = message.getAttribute("version");
5203 if (typeof ver !== "string") {
5204 error = "Missing version in <open />";
5205 } else if (ver !== "1.0") {
5206 error = "Wrong version in <open />: " + ver;
5207 }
5208
5209 if (error) {
5210 this._conn._changeConnectStatus(Strophe.Status.CONNFAIL, error);
5211 this._conn._doDisconnect();
5212 return false;
5213 }
5214
5215 return true;
5216 },
5217
5218 /** PrivateFunction: _connect_cb_wrapper
5219 * _Private_ function that handles the first connection messages.
5220 *
5221 * On receiving an opening stream tag this callback replaces itself with the real
5222 * message handler. On receiving a stream error the connection is terminated.
5223 */
5224 _connect_cb_wrapper: function(message) {
5225 if (message.data.indexOf("<open ") === 0 || message.data.indexOf("<?xml") === 0) {
5226 // Strip the XML Declaration, if there is one
5227 var data = message.data.replace(/^(<\?.*?\?>\s*)*/, "");
5228 if (data === ‘‘) return;
5229
5230 var streamStart = new DOMParser().parseFromString(data, "text/xml").documentElement;
5231 this._conn.xmlInput(streamStart);
5232 this._conn.rawInput(message.data);
5233
5234 //_handleStreamSteart will check for XML errors and disconnect on error
5235 if (this._handleStreamStart(streamStart)) {
5236 //_connect_cb will check for stream:error and disconnect on error
5237 this._connect_cb(streamStart);
5238 }
5239 } else if (message.data.indexOf("<close ") === 0) { //‘<close xmlns="urn:ietf:params:xml:ns:xmpp-framing />‘) {
5240 this._conn.rawInput(message.data);
5241 this._conn.xmlInput(message);
5242 var see_uri = message.getAttribute("see-other-uri");
5243 if (see_uri) {
5244 this._conn._changeConnectStatus(Strophe.Status.REDIRECT, "Received see-other-uri, resetting connection");
5245 this._conn.reset();
5246 this._conn.service = see_uri;
5247 this._connect();
5248 } else {
5249 this._conn._changeConnectStatus(Strophe.Status.CONNFAIL, "Received closing stream");
5250 this._conn._doDisconnect();
5251 }
5252 } else {
5253 var string = this._streamWrap(message.data);
5254 var elem = new DOMParser().parseFromString(string, "text/xml").documentElement;
5255 this.socket.onmessage = this._onMessage.bind(this);
5256 this._conn._connect_cb(elem, null, message.data);
5257 }
5258 },
5259
5260 /** PrivateFunction: _disconnect
5261 * _Private_ function called by Strophe.Connection.disconnect
5262 *
5263 * Disconnects and sends a last stanza if one is given
5264 *
5265 * Parameters:
5266 * (Request) pres - This stanza will be sent before disconnecting.
5267 */
5268 _disconnect: function (pres)
5269 {
5270 if (this.socket && this.socket.readyState !== WebSocket.CLOSED) {
5271 if (pres) {
5272 this._conn.send(pres);
5273 }
5274 var close = $build("close", { "xmlns": Strophe.NS.FRAMING, });
5275 this._conn.xmlOutput(close);
5276 var closeString = Strophe.serialize(close);
5277 this._conn.rawOutput(closeString);
5278 try {
5279 this.socket.send(closeString);
5280 } catch (e) {
5281 Strophe.info("Couldn‘t send <close /> tag.");
5282 }
5283 }
5284 this._conn._doDisconnect();
5285 },
5286
5287 /** PrivateFunction: _doDisconnect
5288 * _Private_ function to disconnect.
5289 *
5290 * Just closes the Socket for WebSockets
5291 */
5292 _doDisconnect: function ()
5293 {
5294 Strophe.info("WebSockets _doDisconnect was called");
5295 this._closeSocket();
5296 },
5297
5298 /** PrivateFunction _streamWrap
5299 * _Private_ helper function to wrap a stanza in a <stream> tag.
5300 * This is used so Strophe can process stanzas from WebSockets like BOSH
5301 */
5302 _streamWrap: function (stanza)
5303 {
5304 return "<wrapper>" + stanza + ‘</wrapper>‘;
5305 },
5306
5307
5308 /** PrivateFunction: _closeSocket
5309 * _Private_ function to close the WebSocket.
5310 *
5311 * Closes the socket if it is still open and deletes it
5312 */
5313 _closeSocket: function ()
5314 {
5315 if (this.socket) { try {
5316 this.socket.close();
5317 } catch (e) {} }
5318 this.socket = null;
5319 },
5320
5321 /** PrivateFunction: _emptyQueue
5322 * _Private_ function to check if the message queue is empty.
5323 *
5324 * Returns:
5325 * True, because WebSocket messages are send immediately after queueing.
5326 */
5327 _emptyQueue: function ()
5328 {
5329 return true;
5330 },
5331
5332 /** PrivateFunction: _onClose
5333 * _Private_ function to handle websockets closing.
5334 *
5335 * Nothing to do here for WebSockets
5336 */
5337 _onClose: function() {
5338 if(this._conn.connected && !this._conn.disconnecting) {
5339 Strophe.error("Websocket closed unexcectedly");
5340 this._conn._doDisconnect();
5341 } else {
5342 Strophe.info("Websocket closed");
5343 }
5344 },
5345
5346 /** PrivateFunction: _no_auth_received
5347 *
5348 * Called on stream start/restart when no stream:features
5349 * has been received.
5350 */
5351 _no_auth_received: function (_callback)
5352 {
5353 Strophe.error("Server did not send any auth methods");
5354 this._conn._changeConnectStatus(Strophe.Status.CONNFAIL, "Server did not send any auth methods");
5355 if (_callback) {
5356 _callback = _callback.bind(this._conn);
5357 _callback();
5358 }
5359 this._conn._doDisconnect();
5360 },
5361
5362 /** PrivateFunction: _onDisconnectTimeout
5363 * _Private_ timeout handler for handling non-graceful disconnection.
5364 *
5365 * This does nothing for WebSockets
5366 */
5367 _onDisconnectTimeout: function () {},
5368
5369 /** PrivateFunction: _abortAllRequests
5370 * _Private_ helper function that makes sure all pending requests are aborted.
5371 */
5372 _abortAllRequests: function () {},
5373
5374 /** PrivateFunction: _onError
5375 * _Private_ function to handle websockets errors.
5376 *
5377 * Parameters:
5378 * (Object) error - The websocket error.
5379 */
5380 _onError: function(error) {
5381 Strophe.error("Websocket error " + error);
5382 this._conn._changeConnectStatus(Strophe.Status.CONNFAIL, "The WebSocket connection could not be established was disconnected.");
5383 this._disconnect();
5384 },
5385
5386 /** PrivateFunction: _onIdle
5387 * _Private_ function called by Strophe.Connection._onIdle
5388 *
5389 * sends all queued stanzas
5390 */
5391 _onIdle: function () {
5392 var data = this._conn._data;
5393 if (data.length > 0 && !this._conn.paused) {
5394 for (var i = 0; i < data.length; i++) {
5395 if (data[i] !== null) {
5396 var stanza, rawStanza;
5397 if (data[i] === "restart") {
5398 stanza = this._buildStream().tree();
5399 } else {
5400 stanza = data[i];
5401 }
5402 rawStanza = Strophe.serialize(stanza);
5403 this._conn.xmlOutput(stanza);
5404 this._conn.rawOutput(rawStanza);
5405 this.socket.send(rawStanza);
5406 }
5407 }
5408 this._conn._data = [];
5409 }
5410 },
5411
5412 /** PrivateFunction: _onMessage
5413 * _Private_ function to handle websockets messages.
5414 *
5415 * This function parses each of the messages as if they are full documents. [TODO : We may actually want to use a SAX Push parser].
5416 *
5417 * Since all XMPP traffic starts with "<stream:stream version=‘1.0‘ xml:lang=‘en‘ xmlns=‘jabber:client‘ xmlns:stream=‘http://etherx.jabber.org/streams‘ id=‘3697395463‘ from=‘SERVER‘>"
5418 * The first stanza will always fail to be parsed...
5419 * Addtionnaly, the seconds stanza will always be a <stream:features> with the stream NS defined in the previous stanza... so we need to ‘force‘ the inclusion of the NS in this stanza!
5420 *
5421 * Parameters:
5422 * (string) message - The websocket message.
5423 */
5424 _onMessage: function(message) {
5425 var elem, data;
5426 // check for closing stream
5427 var close = ‘<close xmlns="urn:ietf:params:xml:ns:xmpp-framing" />‘;
5428 if (message.data === close) {
5429 this._conn.rawInput(close);
5430 this._conn.xmlInput(message);
5431 if (!this._conn.disconnecting) {
5432 this._conn._doDisconnect();
5433 }
5434 return;
5435 } else if (message.data.search("<open ") === 0) {
5436 // This handles stream restarts
5437 elem = new DOMParser().parseFromString(message.data, "text/xml").documentElement;
5438
5439 if (!this._handleStreamStart(elem)) {
5440 return;
5441 }
5442 } else {
5443 data = this._streamWrap(message.data);
5444 elem = new DOMParser().parseFromString(data, "text/xml").documentElement;
5445 }
5446
5447 if (this._check_streamerror(elem, Strophe.Status.ERROR)) {
5448 return;
5449 }
5450
5451 //handle unavailable presence stanza before disconnecting
5452 if (this._conn.disconnecting &&
5453 elem.firstChild.nodeName === "presence" &&
5454 elem.firstChild.getAttribute("type") === "unavailable") {
5455 this._conn.xmlInput(elem);
5456 this._conn.rawInput(Strophe.serialize(elem));
5457 // if we are already disconnecting we will ignore the unavailable stanza and
5458 // wait for the </stream:stream> tag before we close the connection
5459 return;
5460 }
5461 this._conn._dataRecv(elem, message.data);
5462 },
5463
5464 /** PrivateFunction: _onOpen
5465 * _Private_ function to handle websockets connection setup.
5466 *
5467 * The opening stream tag is sent here.
5468 */
5469 _onOpen: function() {
5470 Strophe.info("Websocket open");
5471 var start = this._buildStream();
5472 this._conn.xmlOutput(start.tree());
5473
5474 var startString = Strophe.serialize(start);
5475 this._conn.rawOutput(startString);
5476 this.socket.send(startString);
5477 },
5478
5479 /** PrivateFunction: _reqToData
5480 * _Private_ function to get a stanza out of a request.
5481 *
5482 * WebSockets don‘t use requests, so the passed argument is just returned.
5483 *
5484 * Parameters:
5485 * (Object) stanza - The stanza.
5486 *
5487 * Returns:
5488 * The stanza that was passed.
5489 */
5490 _reqToData: function (stanza)
5491 {
5492 return stanza;
5493 },
5494
5495 /** PrivateFunction: _send
5496 * _Private_ part of the Connection.send function for WebSocket
5497 *
5498 * Just flushes the messages that are in the queue
5499 */
5500 _send: function () {
5501 this._conn.flush();
5502 },
5503
5504 /** PrivateFunction: _sendRestart
5505 *
5506 * Send an xmpp:restart stanza.
5507 */
5508 _sendRestart: function ()
5509 {
5510 clearTimeout(this._conn._idleTimeout);
5511 this._conn._onIdle.bind(this._conn)();
5512 }
5513 };
5514 return Strophe;
5515 }));
5516
5517 /* jshint ignore:start */
5518 if (callback) {
5519 return callback(Strophe, $build, $msg, $iq, $pres);
5520 }
5521
5522
5523 })(function (Strophe, build, msg, iq, pres) {
5524 window.Strophe = Strophe;
5525 window.$build = build;
5526 window.$msg = msg;
5527 window.$iq = iq;
5528 window.$pres = pres;
5529 });
5530 /* jshint ignore:end */
5531
5532
5533
5534 /*utf*/
5535 function utf16to8(str) {
5536 var out, i, len, c;
5537 out = "";
5538 len = str.length;
5539 for(i = 0; i < len; i++) {
5540 c = str.charCodeAt(i);
5541 if ((c >= 0x0001) && (c <= 0x007F)) {
5542 out += str.charAt(i);
5543 } else if (c > 0x07FF) {
5544 out += String.fromCharCode(0xE0 | ((c >> 12) & 0x0F));
5545 out += String.fromCharCode(0x80 | ((c >> 6) & 0x3F));
5546 out += String.fromCharCode(0x80 | ((c >> 0) & 0x3F));
5547 } else {
5548 out += String.fromCharCode(0xC0 | ((c >> 6) & 0x1F));
5549 out += String.fromCharCode(0x80 | ((c >> 0) & 0x3F));
5550 }
5551 }
5552 return out;
5553 }
5554 //utf-16转utf-8
5555 function utf8to16(str) {
5556 var out, i, len, c;
5557 var char2, char3;
5558 out = "";
5559 len = str.length;
5560 i = 0;
5561 while(i < len) {
5562 c = str.charCodeAt(i++);
5563 switch(c >> 4)
5564 {
5565 case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
5566 // 0xxxxxxx
5567 out += str.charAt(i-1);
5568 break;
5569 case 12: case 13:
5570 // 110x xxxx 10xx xxxx
5571 char2 = str.charCodeAt(i++);
5572 out += String.fromCharCode(((c & 0x1F) << 6) | (char2 & 0x3F));
5573 break;
5574 case 14:
5575 // 1110 xxxx 10xx xxxx 10xx xxxx
5576 char2 = str.charCodeAt(i++);
5577 char3 = str.charCodeAt(i++);
5578 out += String.fromCharCode(((c & 0x0F) << 12) |
5579 ((char2 & 0x3F) << 6) |
5580 ((char3 & 0x3F) << 0));
5581 break;
5582 }
5583 }
5584 return out;
5585 }
2、后台插件进行编码解析
Web界面
var iq=$iq({id:"iqwd_factorylogin",type:"get"}).
c("query",{xmlns:"query-factorylogin"}).
c("item").
c("username").cht("张三");
Openfire插件
String username= Base64.getFromBase64(item.elementText("username"));
1 package com.plugin.common;
2
3 import java.io.UnsupportedEncodingException;
4
5 import sun.misc.BASE64Decoder;
6 import sun.misc.BASE64Encoder;
7
8 public class Base64 {
9 // 加密
10 public static String getBase64(String str) {
11 byte[] b = null;
12 String s = null;
13 try {
14 b = str.getBytes("utf-8");
15 } catch (UnsupportedEncodingException e) {
16 e.printStackTrace();
17 }
18 if (b != null) {
19 s = new BASE64Encoder().encode(b);
20 }
21 return s;
22 }
23
24 // 解密
25 public static String getFromBase64(String s) {
26 byte[] b = null;
27 String result = null;
28 if (s != null) {
29 BASE64Decoder decoder = new BASE64Decoder();
30 try {
31 b = decoder.decodeBuffer(s);
32 result = new String(b, "utf-8");
33 } catch (Exception e) {
34 e.printStackTrace();
35 }
36 }
37 return result;
38 }
39
40 }
时间： 2024-10-27 08:42:16