Source: jsxc.lib.xmpp.js

  1. /**
  2.  * Handle XMPP stuff.
  3.  *
  4.  * @namespace jsxc.xmpp
  5.  */
  6. jsxc.xmpp = {
  7.    conn: null, // connection
  9.    /**
  10.     * Create new connection or attach to old
  11.     *
  12.     * @name login
  13.     * @memberOf jsxc.xmpp
  14.     * @private
  15.     */
  16.    /**
  17.     * Create new connection with given parameters.
  18.     *
  19.     * @name login^2
  20.     * @param {string} jid
  21.     * @param {string} password
  22.     * @memberOf jsxc.xmpp
  23.     * @private
  24.     */
  25.    /**
  26.     * Attach connection with given parameters.
  27.     *
  28.     * @name login^3
  29.     * @param {string} jid
  30.     * @param {string} sid
  31.     * @param {string} rid
  32.     * @memberOf jsxc.xmpp
  33.     * @private
  34.     */
  35.    login: function() {
  37.       if (jsxc.xmpp.conn && jsxc.xmpp.conn.authenticated) {
  38.          jsxc.debug('Connection already authenticated.');
  39.          return;
  40.       }
  42.       var jid = null,
  43.          password = null,
  44.          sid = null,
  45.          rid = null;
  47.       switch (arguments.length) {
  48.          case 2:
  49.             jid = arguments[0];
  50.             password = arguments[1];
  51.             break;
  52.          case 3:
  53.             jid = arguments[0];
  54.             sid = arguments[1];
  55.             rid = arguments[2];
  56.             break;
  57.          default:
  58.             sid = jsxc.storage.getItem('sid');
  59.             rid = jsxc.storage.getItem('rid');
  61.             if (sid !== null && rid !== null) {
  62.                jid = jsxc.storage.getItem('jid');
  63.             } else {
  64.                sid = jsxc.options.xmpp.sid || null;
  65.                rid = jsxc.options.xmpp.rid || null;
  66.                jid = jsxc.options.xmpp.jid;
  67.             }
  68.       }
  70.       if (!jid) {
  71.          jsxc.warn('Jid required for login');
  73.          return;
  74.       }
  76.       if (!jsxc.bid) {
  77.          jsxc.bid = jsxc.jidToBid(jid);
  78.       }
  80.       var url = jsxc.options.get('xmpp').url;
  82.       if (!url) {
  83.          jsxc.warn('xmpp.url required for login');
  85.          return;
  86.       }
  88.       if (!(jsxc.xmpp.conn && jsxc.xmpp.conn.connected)) {
  89.          // Register eventlistener
  90.          $(document).on('connected.jsxc', jsxc.xmpp.connected);
  91.          $(document).on('attached.jsxc', jsxc.xmpp.attached);
  92.          $(document).on('disconnected.jsxc', jsxc.xmpp.disconnected);
  93.          $(document).on('connfail.jsxc', jsxc.xmpp.onConnfail);
  94.          $(document).on('authfail.jsxc', jsxc.xmpp.onAuthFail);
  96.          Strophe.addNamespace('RECEIPTS', 'urn:xmpp:receipts');
  97.          Strophe.addNamespace('VERSION', 'jabber:iq:version');
  98.       }
  100.       // Create new connection (no login)
  101.       jsxc.xmpp.conn = new Strophe.Connection(url);
  103.       if (jsxc.storage.getItem('debug') === true) {
  104.          jsxc.xmpp.conn.xmlInput = function(data) {
  105.             console.log('<', data);
  106.          };
  107.          jsxc.xmpp.conn.xmlOutput = function(data) {
  108.             console.log('>', data);
  109.          };
  110.       }
  112.       jsxc.xmpp.conn.nextValidRid = jsxc.xmpp.onRidChange;
  114.       var callback = function(status, condition) {
  116.          jsxc.debug(Object.getOwnPropertyNames(Strophe.Status)[status] + ': ' + condition);
  118.          switch (status) {
  119.             case Strophe.Status.CONNECTING:
  120.                $(document).trigger('connecting.jsxc');
  121.                break;
  122.             case Strophe.Status.CONNECTED:
  123.                jsxc.bid = jsxc.jidToBid(jsxc.xmpp.conn.jid.toLowerCase());
  124.                $(document).trigger('connected.jsxc');
  125.                break;
  126.             case Strophe.Status.ATTACHED:
  127.                $(document).trigger('attached.jsxc');
  128.                break;
  129.             case Strophe.Status.DISCONNECTED:
  130.                $(document).trigger('disconnected.jsxc');
  131.                break;
  132.             case Strophe.Status.CONNFAIL:
  133.                $(document).trigger('connfail.jsxc');
  134.                break;
  135.             case Strophe.Status.AUTHFAIL:
  136.                $(document).trigger('authfail.jsxc');
  137.                break;
  138.          }
  139.       };
  141.       if (jsxc.xmpp.conn.caps) {
  142.          jsxc.xmpp.conn.caps.node = 'http://jsxc.org/';
  143.       }
  145.       jsxc.changeState(jsxc.CONST.STATE.ESTABLISHING);
  147.       if (sid && rid) {
  148.          jsxc.debug('Try to attach');
  149.          jsxc.debug('SID: ' + sid);
  151.          jsxc.xmpp.conn.attach(jid, sid, rid, callback);
  152.       } else {
  153.          jsxc.debug('New connection');
  155.          if (jsxc.xmpp.conn.caps) {
  156.             // Add system handler, because user handler isn't called before
  157.             // we are authenticated
  158.             // @REVIEW this could maybe retrieved from jsxc.xmpp.conn.features
  159.             jsxc.xmpp.conn._addSysHandler(function(stanza) {
  160.                var from = jsxc.xmpp.conn.domain,
  161.                   c = stanza.querySelector('c'),
  162.                   ver = c.getAttribute('ver'),
  163.                   node = c.getAttribute('node');
  165.                var _jidNodeIndex = JSON.parse(localStorage.getItem('strophe.caps._jidNodeIndex')) || {};
  167.                jsxc.xmpp.conn.caps._jidVerIndex[from] = ver;
  168.                _jidNodeIndex[from] = node;
  170.                localStorage.setItem('strophe.caps._jidVerIndex', JSON.stringify(jsxc.xmpp.conn.caps._jidVerIndex));
  171.                localStorage.setItem('strophe.caps._jidNodeIndex', JSON.stringify(_jidNodeIndex));
  172.             }, Strophe.NS.CAPS);
  173.          }
  175.          jsxc.xmpp.conn.connect(jid, password || jsxc.options.xmpp.password, callback);
  176.       }
  177.    },
  179.    /**
  180.     * Logs user out of his xmpp session and does some clean up.
  181.     *
  182.     * @param {boolean} complete If set to false, roster will not be removed
  183.     * @returns {Boolean}
  184.     */
  185.    logout: function(complete) {
  187.       jsxc.storage.setUserItem('forcedLogout', true);
  189.       jsxc.triggeredFromElement = (typeof complete === 'boolean') ? complete : true;
  191.       if (!jsxc.master) {
  192.          // instruct master
  193.          jsxc.storage.removeItem('sid');
  195.          // jsxc.xmpp.disconnected is called if master deletes alive after logout
  196.          return true;
  197.       }
  199.       // REVIEW: this should maybe moved to xmpp.disconnected
  200.       // clean up
  201.       jsxc.storage.removeUserItem('windowlist');
  202.       jsxc.storage.removeUserItem('unreadMsg');
  204.       if (jsxc.gui.favicon) {
  205.          jsxc.gui.favicon.badge(0);
  206.       }
  208.       // Hide dropdown menu
  209.       $('body').click();
  211.       if (!jsxc.xmpp.conn || !jsxc.xmpp.conn.authenticated) {
  212.          return true;
  213.       }
  215.       // restore all otr objects
  216.       $.each(jsxc.storage.getUserItem('otrlist') || {}, function(i, val) {
  217.          jsxc.otr.create(val);
  218.       });
  220.       var numOtr = Object.keys(jsxc.otr.objects || {}).length + 1;
  221.       var disReady = function() {
  222.          if (--numOtr <= 0) {
  223.             jsxc.xmpp.conn.flush();
  225.             setTimeout(function() {
  226.                jsxc.xmpp.conn.disconnect();
  227.             }, 600);
  228.          }
  229.       };
  231.       // end all private conversations
  232.       $.each(jsxc.otr.objects || {}, function(key, obj) {
  233.          if (obj.msgstate === OTR.CONST.MSGSTATE_ENCRYPTED) {
  234.             obj.endOtr.call(obj, function() {
  235.                obj.init.call(obj);
  236.                jsxc.otr.backup(key);
  238.                disReady();
  239.             });
  240.          } else {
  241.             disReady();
  242.          }
  243.       });
  245.       disReady();
  247.       // Trigger real logout in jsxc.xmpp.disconnected()
  248.       return false;
  249.    },
  251.    /**
  252.     * Triggered if connection is established
  253.     *
  254.     * @private
  255.     */
  256.    connected: function() {
  258.       jsxc.xmpp.conn.pause();
  260.       jsxc.xmpp.initNewConnection();
  262.       jsxc.xmpp.saveSessionParameter();
  264.       var rosterVerSupport = $(jsxc.xmpp.conn.features).find('[xmlns="urn:xmpp:features:rosterver"]').length > 0;
  265.       jsxc.storage.setUserItem('rosterVerSupport', rosterVerSupport);
  267.       jsxc.storage.removeUserItem('forcedLogout');
  269.       if (jsxc.options.loginForm.triggered) {
  270.          switch (jsxc.options.loginForm.onConnected || 'submit') {
  271.             case 'submit':
  272.                jsxc.submitLoginForm();
  273.                return;
  274.             case false:
  275.                return;
  276.          }
  277.       }
  279.       // start chat
  281.       jsxc.gui.dialog.close();
  283.       jsxc.xmpp.conn.resume();
  284.       jsxc.onMaster();
  286.       jsxc.changeState(jsxc.CONST.STATE.READY);
  287.       $(document).trigger('attached.jsxc');
  288.    },
  290.    /**
  291.     * Triggered if connection is attached
  292.     *
  293.     * @private
  294.     */
  295.    attached: function() {
  297.       $('#jsxc_roster').removeClass('jsxc_noConnection');
  299.       Strophe.addNamespace('VERSION', 'jabber:iq:version');
  301.       jsxc.xmpp.conn.addHandler(jsxc.xmpp.onRosterChanged, 'jabber:iq:roster', 'iq', 'set');
  302.       jsxc.xmpp.conn.addHandler(jsxc.xmpp.onChatMessage, null, 'message', 'chat');
  303.       jsxc.xmpp.conn.addHandler(jsxc.xmpp.onErrorMessage, null, 'message', 'error');
  304.       jsxc.xmpp.conn.addHandler(jsxc.xmpp.onHeadlineMessage, null, 'message', 'headline');
  305.       jsxc.xmpp.conn.addHandler(jsxc.xmpp.onReceived, null, 'message');
  306.       jsxc.xmpp.conn.addHandler(jsxc.xmpp.onPresence, null, 'presence');
  307.       jsxc.xmpp.conn.addHandler(jsxc.xmpp.onVersionRequest, Strophe.NS.VERSION, 'iq', 'get');
  309.       jsxc.gui.init();
  311.       var caps = jsxc.xmpp.conn.caps;
  312.       var domain = jsxc.xmpp.conn.domain;
  314.       if (caps) {
  315.          var conditionalEnable = function() {};
  317.          if (jsxc.options.get('carbons').enable) {
  318.             conditionalEnable = function() {
  319.                if (jsxc.xmpp.conn.caps.hasFeatureByJid(domain, jsxc.CONST.NS.CARBONS)) {
  320.                   jsxc.xmpp.carbons.enable();
  321.                }
  322.             };
  324.             $(document).on('caps.strophe', function onCaps(ev, from) {
  326.                if (from !== domain) {
  327.                   return;
  328.                }
  330.                conditionalEnable();
  332.                $(document).off('caps.strophe', onCaps);
  333.             });
  334.          }
  336.          if (typeof caps._knownCapabilities[caps._jidVerIndex[domain]] === 'undefined') {
  337.             var _jidNodeIndex = JSON.parse(localStorage.getItem('strophe.caps._jidNodeIndex')) || {};
  339.             jsxc.debug('Request server capabilities');
  341.             caps._requestCapabilities(jsxc.xmpp.conn.domain, _jidNodeIndex[domain], caps._jidVerIndex[domain]);
  342.          } else {
  343.             // We know server caps
  344.             conditionalEnable();
  345.          }
  346.       }
  348.       var rosterLoaded = jsxc.storage.getUserItem('rosterLoaded');
  350.       // Only load roaster if necessary
  351.       if (rosterLoaded !== jsxc.xmpp.conn._proto.sid) {
  352.          // in order to not overide existing presence information, we send
  353.          // pres first after roster is ready
  354.          $(document).one('cloaded.roster.jsxc', jsxc.xmpp.sendPres);
  356.          $('#jsxc_roster > p:first').remove();
  358.          var queryAttr = {
  359.             xmlns: 'jabber:iq:roster'
  360.          };
  362.          if (jsxc.storage.getUserItem('rosterVerSupport')) {
  363.             // @TODO check if we really cached the roster
  364.             queryAttr.ver = jsxc.storage.getUserItem('rosterVer') || '';
  365.          }
  367.          var iq = $iq({
  368.             type: 'get'
  369.          }).c('query', queryAttr);
  371.          jsxc.xmpp.conn.sendIQ(iq, jsxc.xmpp.onRoster);
  372.       } else {
  373.          jsxc.xmpp.sendPres();
  375.          if (!jsxc.restoreCompleted) {
  376.             jsxc.gui.restore();
  377.          }
  378.       }
  380.       jsxc.xmpp.saveSessionParameter();
  382.       jsxc.masterActions();
  384.       jsxc.changeState(jsxc.CONST.STATE.READY);
  385.    },
  387.    saveSessionParameter: function() {
  389.       var nomJid = Strophe.getBareJidFromJid(jsxc.xmpp.conn.jid).toLowerCase() + '/' + Strophe.getResourceFromJid(jsxc.xmpp.conn.jid);
  391.       // Save sid and jid
  392.       jsxc.storage.setItem('sid', jsxc.xmpp.conn._proto.sid);
  393.       jsxc.storage.setItem('jid', nomJid);
  394.    },
  396.    initNewConnection: function() {
  397.       jsxc.storage.removeUserItem('windowlist');
  398.       jsxc.storage.removeUserItem('own');
  399.       jsxc.storage.removeUserItem('avatar', 'own');
  400.       jsxc.storage.removeUserItem('otrlist');
  401.       jsxc.storage.removeUserItem('unreadMsg');
  402.       jsxc.storage.removeUserItem('features');
  404.       // reset user options
  405.       jsxc.storage.removeUserElement('options', 'RTCPeerConfig');
  406.    },
  408.    /**
  409.     * Sends presence stanza to server.
  410.     */
  411.    sendPres: function() {
  412.       // disco stuff
  413.       if (jsxc.xmpp.conn.disco) {
  414.          jsxc.xmpp.conn.disco.addIdentity('client', 'web', 'JSXC');
  415.          jsxc.xmpp.conn.disco.addFeature(Strophe.NS.DISCO_INFO);
  416.          jsxc.xmpp.conn.disco.addFeature(Strophe.NS.RECEIPTS);
  417.          jsxc.xmpp.conn.disco.addFeature(Strophe.NS.VERSION);
  418.       }
  420.       // create presence stanza
  421.       var pres = $pres();
  423.       if (jsxc.xmpp.conn.caps) {
  424.          // attach caps
  425.          pres.c('c', jsxc.xmpp.conn.caps.generateCapsAttrs()).up();
  426.       }
  428.       var presState = jsxc.storage.getUserItem('presence') || 'online';
  429.       if (presState !== 'online') {
  430.          pres.c('show').t(presState).up();
  431.       }
  433.       var priority = jsxc.options.get('priority');
  434.       if (priority && typeof priority[presState] !== 'undefined' && parseInt(priority[presState]) !== 0) {
  435.          pres.c('priority').t(priority[presState]).up();
  436.       }
  438.       jsxc.debug('Send presence', pres.toString());
  439.       jsxc.xmpp.conn.send(pres);
  441.       if (!jsxc.storage.getUserItem('features')) {
  442.          jsxc.xmpp.conn.flush();
  444.          var barJid = Strophe.getBareJidFromJid(jsxc.xmpp.conn.jid);
  446.          jsxc.xmpp.conn.disco.info(barJid, undefined, function(stanza) {
  447.             var features = $(stanza).find('feature').map(function() {
  448.                return $(this).attr('var');
  449.             });
  451.             jsxc.storage.setUserItem('features', features.toArray());
  452.             $(document).trigger('features.jsxc');
  453.          });
  454.       } else {
  455.          $(document).trigger('features.jsxc');
  456.       }
  457.    },
  459.    /**
  460.     * Triggered if lost connection
  461.     *
  462.     * @private
  463.     */
  464.    disconnected: function() {
  465.       jsxc.debug('disconnected');
  467.       //jsxc.storage.removeItem('jid');
  468.       jsxc.storage.removeItem('sid');
  469.       jsxc.storage.removeItem('rid');
  470.       jsxc.storage.removeItem('hidden');
  471.       jsxc.storage.removeUserItem('avatar', 'own');
  472.       jsxc.storage.removeUserItem('otrlist');
  473.       jsxc.storage.removeUserItem('features');
  475.       $(document).off('connected.jsxc', jsxc.xmpp.connected);
  476.       $(document).off('attached.jsxc', jsxc.xmpp.attached);
  477.       $(document).off('disconnected.jsxc', jsxc.xmpp.disconnected);
  478.       $(document).off('connfail.jsxc', jsxc.xmpp.onConnfail);
  479.       $(document).off('authfail.jsxc', jsxc.xmpp.onAuthFail);
  481.       jsxc.xmpp.conn = null;
  483.       $('#jsxc_windowList').remove();
  485.       if (jsxc.triggeredFromElement) {
  486.          $(document).trigger('toggle.roster.jsxc', ['hidden', 0]);
  487.          jsxc.gui.roster.ready = false;
  488.          $('#jsxc_roster').remove();
  490.          // REVIEW: logoutElement without href attribute?
  491.          if (jsxc.triggeredFromLogout) {
  492.             window.location = jsxc.options.logoutElement.attr('href');
  493.          }
  494.       } else {
  495.          jsxc.gui.roster.noConnection();
  496.       }
  498.       window.clearInterval(jsxc.keepaliveInterval);
  499.       jsxc.role_allocation = false;
  500.       jsxc.master = false;
  501.       jsxc.storage.removeItem('alive');
  503.       jsxc.changeState(jsxc.CONST.STATE.SUSPEND);
  504.    },
  506.    /**
  507.     * Triggered on connection fault
  508.     *
  509.     * @param {String} condition information why we lost the connection
  510.     * @private
  511.     */
  512.    onConnfail: function(ev, condition) {
  513.       jsxc.debug('XMPP connection failed: ' + condition);
  515.       if (jsxc.options.loginForm.triggered) {
  516.          jsxc.submitLoginForm();
  517.       }
  518.    },
  520.    /**
  521.     * Triggered on auth fail.
  522.     *
  523.     * @private
  524.     */
  525.    onAuthFail: function() {
  527.       if (jsxc.options.loginForm.triggered) {
  528.          switch (jsxc.options.loginForm.onAuthFail || 'ask') {
  529.             case 'ask':
  530.                jsxc.gui.showAuthFail();
  531.                break;
  532.             case 'submit':
  533.                jsxc.submitLoginForm();
  534.                break;
  535.             case 'quiet':
  536.             case false:
  537.                return;
  538.          }
  539.       }
  540.    },
  542.    /**
  543.     * Triggered on initial roster load
  544.     *
  545.     * @param {dom} iq
  546.     * @private
  547.     */
  548.    onRoster: function(iq) {
  549.       jsxc.debug('Load roster', iq);
  551.       jsxc.storage.setUserItem('rosterLoaded', jsxc.xmpp.conn._proto.sid);
  553.       if ($(iq).find('query').length === 0) {
  554.          jsxc.debug('Use cached roster');
  556.          jsxc.restoreRoster();
  557.          return;
  558.       }
  560.       var buddies = [];
  562.       $(iq).find('item').each(function() {
  563.          var jid = $(this).attr('jid');
  564.          var name = $(this).attr('name') || jid;
  565.          var bid = jsxc.jidToBid(jid);
  566.          var sub = $(this).attr('subscription');
  568.          buddies.push(bid);
  570.          jsxc.storage.removeUserItem('res', bid);
  572.          jsxc.storage.saveBuddy(bid, {
  573.             jid: jid,
  574.             name: name,
  575.             status: 0,
  576.             sub: sub,
  577.             res: [],
  578.             rnd: Math.random() // force storage event
  579.          });
  581.          jsxc.gui.roster.add(bid);
  582.       });
  584.       if (buddies.length === 0) {
  585.          jsxc.gui.roster.empty();
  586.       }
  588.       jsxc.storage.setUserItem('buddylist', buddies);
  590.       if ($(iq).find('query').attr('ver')) {
  591.          jsxc.storage.setUserItem('rosterVer', $(iq).find('query').attr('ver'));
  592.       }
  594.       // load bookmarks
  595.       jsxc.xmpp.bookmarks.load();
  597.       jsxc.gui.roster.loaded = true;
  598.       jsxc.debug('Roster loaded');
  599.       $(document).trigger('cloaded.roster.jsxc');
  600.       jsxc.changeUIState(jsxc.CONST.UISTATE.READY);
  601.    },
  603.    /**
  604.     * Triggerd on roster changes
  605.     *
  606.     * @param {dom} iq
  607.     * @returns {Boolean} True to preserve handler
  608.     * @private
  609.     */
  610.    onRosterChanged: function(iq) {
  612.       var iqSender = $(iq).attr('from');
  613.       var ownBareJid = Strophe.getBareJidFromJid(jsxc.xmpp.conn.jid);
  615.       if (iqSender && iqSender !== ownBareJid) {
  616.          return true;
  617.       }
  619.       jsxc.debug('onRosterChanged', iq);
  621.       // @REVIEW there should be only one item, according to RFC6121
  622.       // https://xmpp.org/rfcs/rfc6121.html#roster-syntax-actions-push
  623.       $(iq).find('item').each(function() {
  624.          var jid = $(this).attr('jid');
  625.          var name = $(this).attr('name') || jid;
  626.          var bid = jsxc.jidToBid(jid);
  627.          var sub = $(this).attr('subscription');
  628.          // var ask = $(this).attr('ask');
  630.          if (sub === 'remove') {
  631.             jsxc.gui.roster.purge(bid);
  632.          } else {
  633.             var bl = jsxc.storage.getUserItem('buddylist');
  635.             if (bl.indexOf(bid) < 0) {
  636.                bl.push(bid); // (INFO) push returns the new length
  637.                jsxc.storage.setUserItem('buddylist', bl);
  638.             }
  640.             var temp = jsxc.storage.saveBuddy(bid, {
  641.                jid: jid,
  642.                name: name,
  643.                sub: sub
  644.             });
  646.             if (temp === 'updated') {
  648.                jsxc.gui.update(bid);
  649.                jsxc.gui.roster.reorder(bid);
  650.             } else {
  651.                jsxc.gui.roster.add(bid);
  652.             }
  653.          }
  655.          // Remove pending friendship request from notice list
  656.          if (sub === 'from' || sub === 'both') {
  657.             var notices = jsxc.storage.getUserItem('notices');
  658.             var noticeKey = null,
  659.                notice;
  661.             for (noticeKey in notices) {
  662.                notice = notices[noticeKey];
  664.                if (notice.fnName === 'gui.showApproveDialog' && notice.fnParams[0] === jid) {
  665.                   jsxc.debug('Remove notice with key ' + noticeKey);
  667.                   jsxc.notice.remove(noticeKey);
  668.                }
  669.             }
  670.          }
  671.       });
  673.       if ($(iq).find('query').attr('ver')) {
  674.          jsxc.storage.setUserItem('rosterVer', $(iq).find('query').attr('ver'));
  675.       }
  677.       if (!jsxc.storage.getUserItem('buddylist') || jsxc.storage.getUserItem('buddylist').length === 0) {
  678.          jsxc.gui.roster.empty();
  679.       } else {
  680.          $('#jsxc_roster > p:first').remove();
  681.       }
  683.       // preserve handler
  684.       return true;
  685.    },
  687.    /**
  688.     * Triggered on incoming presence stanzas
  689.     *
  690.     * @param {dom} presence
  691.     * @private
  692.     */
  693.    onPresence: function(presence) {
  694.       /*
  695.        * <presence xmlns='jabber:client' type='unavailable' from='' to=''/>
  696.        *
  697.        * <presence xmlns='jabber:client' from='' to=''> <priority>5</priority>
  698.        * <c xmlns='http://jabber.org/protocol/caps'
  699.        * node='http://psi-im.org/caps' ver='caps-b75d8d2b25' ext='ca cs
  700.        * ep-notify-2 html'/> </presence>
  701.        *
  702.        * <presence xmlns='jabber:client' from='' to=''> <show>chat</show>
  703.        * <status></status> <priority>5</priority> <c
  704.        * xmlns='http://jabber.org/protocol/caps' node='http://psi-im.org/caps'
  705.        * ver='caps-b75d8d2b25' ext='ca cs ep-notify-2 html'/> </presence>
  706.        */
  707.       jsxc.debug('onPresence', presence);
  709.       var ptype = $(presence).attr('type');
  710.       var from = $(presence).attr('from');
  711.       var jid = Strophe.getBareJidFromJid(from).toLowerCase();
  712.       var r = Strophe.getResourceFromJid(from);
  713.       var bid = jsxc.jidToBid(jid);
  714.       var data = jsxc.storage.getUserItem('buddy', bid) || {};
  715.       var res = jsxc.storage.getUserItem('res', bid) || {};
  716.       var status = null;
  717.       var xVCard = $(presence).find('x[xmlns="vcard-temp:x:update"]');
  719.       if (jid === Strophe.getBareJidFromJid(jsxc.storage.getItem("jid"))) {
  720.          return true;
  721.       }
  723.       if (ptype === 'error') {
  724.          $(document).trigger('error.presence.jsxc', [from, presence]);
  726.          var error = $(presence).find('error');
  728.          //@TODO display error message
  729.          jsxc.error('[XMPP] ' + error.attr('code') + ' ' + error.find(">:first-child").prop('tagName'));
  730.          return true;
  731.       }
  733.       // incoming friendship request
  734.       if (ptype === 'subscribe') {
  735.          var bl = jsxc.storage.getUserItem('buddylist');
  737.          if (bl.indexOf(bid) > -1) {
  738.             jsxc.debug('Auto approve contact request, because he is already in our contact list.');
  740.             jsxc.xmpp.resFriendReq(jid, true);
  741.             if (data.sub !== 'to') {
  742.                jsxc.xmpp.addBuddy(jid, data.name);
  743.             }
  745.             return true;
  746.          }
  748.          jsxc.storage.setUserItem('friendReq', {
  749.             jid: jid,
  750.             approve: -1
  751.          });
  752.          jsxc.notice.add({
  753.             msg: $.t('Friendship_request'),
  754.             description: $.t('from') + ' ' + jid,
  755.             type: 'contact'
  756.          }, 'gui.showApproveDialog', [jid]);
  758.          return true;
  759.       } else if (ptype === 'unavailable' || ptype === 'unsubscribed') {
  760.          status = jsxc.CONST.STATUS.indexOf('offline');
  761.       } else {
  762.          var show = $(presence).find('show').text();
  763.          if (show === '') {
  764.             status = jsxc.CONST.STATUS.indexOf('online');
  765.          } else {
  766.             status = jsxc.CONST.STATUS.indexOf(show);
  767.          }
  768.       }
  770.       if (status === 0) {
  771.          delete res[r];
  772.       } else if (r) {
  773.          res[r] = status;
  774.       }
  776.       var maxVal = [];
  777.       var max = 0,
  778.          prop = null;
  779.       for (prop in res) {
  780.          if (res.hasOwnProperty(prop)) {
  781.             if (max <= res[prop]) {
  782.                if (max !== res[prop]) {
  783.                   maxVal = [];
  784.                   max = res[prop];
  785.                }
  786.                maxVal.push(prop);
  787.             }
  788.          }
  789.       }
  791.       if (data.status === 0 && max > 0) {
  792.          // buddy has come online
  793.          jsxc.notification.notify({
  794.             title: data.name,
  795.             msg: $.t('has_come_online'),
  796.             source: bid
  797.          });
  798.       }
  800.       if (data.type !== 'groupchat') {
  801.          data.status = max;
  802.       }
  804.       data.res = maxVal;
  805.       data.jid = jid;
  807.       // Looking for avatar
  808.       if (xVCard.length > 0 && data.type !== 'groupchat') {
  809.          var photo = xVCard.find('photo');
  811.          if (photo.length > 0 && photo.text() !== data.avatar) {
  812.             jsxc.storage.removeUserItem('avatar', data.avatar);
  813.             data.avatar = photo.text();
  814.          }
  815.       }
  817.       // Reset jid
  818.       if (jsxc.gui.window.get(bid).length > 0) {
  819.          jsxc.gui.window.get(bid).data('jid', jid);
  820.       }
  822.       jsxc.storage.setUserItem('buddy', bid, data);
  823.       jsxc.storage.setUserItem('res', bid, res);
  825.       jsxc.debug('Presence (' + from + '): ' + jsxc.CONST.STATUS[status]);
  827.       jsxc.gui.update(bid);
  828.       jsxc.gui.roster.reorder(bid);
  830.       $(document).trigger('presence.jsxc', [from, status, presence]);
  832.       // preserve handler
  833.       return true;
  834.    },
  836.    /**
  837.     * Triggered on incoming message stanzas
  838.     *
  839.     * @param {dom} presence
  840.     * @returns {Boolean}
  841.     * @private
  842.     */
  843.    onChatMessage: function(stanza) {
  844.       var forwarded = $(stanza).find('forwarded[xmlns="' + jsxc.CONST.NS.FORWARD + '"]');
  845.       var message, carbon;
  846.       var originalSender = $(stanza).attr('from');
  848.       if (forwarded.length > 0) {
  849.          message = forwarded.find('> message');
  850.          forwarded = true;
  851.          carbon = $(stanza).find('> [xmlns="' + jsxc.CONST.NS.CARBONS + '"]');
  853.          if (carbon.length === 0) {
  854.             carbon = false;
  855.          } else if (originalSender !== Strophe.getBareJidFromJid(jsxc.xmpp.conn.jid)) {
  856.             // ignore this carbon copy
  857.             return true;
  858.          }
  860.          jsxc.debug('Incoming forwarded message', message);
  861.       } else {
  862.          message = stanza;
  863.          forwarded = false;
  864.          carbon = false;
  866.          jsxc.debug('Incoming message', message);
  867.       }
  869.       var body = $(message).find('body:first').text();
  870.       var htmlBody = $(message).find('body[xmlns="' + Strophe.NS.XHTML + '"]');
  872.       if (!body || (body.match(/\?OTR/i) && forwarded)) {
  873.          return true;
  874.       }
  876.       var type = $(message).attr('type');
  877.       var from = $(message).attr('from');
  878.       var mid = $(message).attr('id');
  879.       var bid;
  881.       var delay = $(message).find('delay[xmlns="urn:xmpp:delay"]');
  883.       var stamp = (delay.length > 0) ? new Date(delay.attr('stamp')) : new Date();
  884.       stamp = stamp.getTime();
  886.       if (carbon) {
  887.          var direction = (carbon.prop("tagName") === 'sent') ? jsxc.Message.OUT : jsxc.Message.IN;
  888.          bid = jsxc.jidToBid((direction === 'out') ? $(message).attr('to') : from);
  890.          jsxc.gui.window.postMessage({
  891.             bid: bid,
  892.             direction: direction,
  893.             msg: body,
  894.             encrypted: false,
  895.             forwarded: forwarded,
  896.             stamp: stamp
  897.          });
  899.          return true;
  901.       } else if (forwarded) {
  902.          // Someone forwarded a message to us
  904.          body = from + ' ' + $.t('to') + ' ' + $(stanza).attr('to') + '"' + body + '"';
  906.          from = $(stanza).attr('from');
  907.       }
  909.       var jid = Strophe.getBareJidFromJid(from);
  910.       bid = jsxc.jidToBid(jid);
  911.       var data = jsxc.storage.getUserItem('buddy', bid);
  912.       var request = $(message).find("request[xmlns='urn:xmpp:receipts']");
  914.       if (data === null) {
  915.          // jid not in roster
  917.          var chat = jsxc.storage.getUserItem('chat', bid) || [];
  919.          if (chat.length === 0) {
  920.             jsxc.notice.add({
  921.                msg: $.t('Unknown_sender'),
  922.                description: $.t('You_received_a_message_from_an_unknown_sender_') + ' (' + bid + ').'
  923.             }, 'gui.showUnknownSender', [bid]);
  924.          }
  926.          var msg = jsxc.removeHTML(body);
  927.          msg = jsxc.escapeHTML(msg);
  929.          var messageObj = new jsxc.Message({
  930.             bid: bid,
  931.             msg: msg,
  932.             direction: jsxc.Message.IN,
  933.             encrypted: false,
  934.             forwarded: forwarded,
  935.             stamp: stamp
  936.          });
  937.          messageObj.save();
  939.          return true;
  940.       }
  942.       var win = jsxc.gui.window.init(bid);
  944.       // If we now the full jid, we use it
  945.       if (type === 'chat') {
  946.          win.data('jid', from);
  947.          jsxc.storage.updateUserItem('buddy', bid, {
  948.             jid: from
  949.          });
  950.       }
  952.       $(document).trigger('message.jsxc', [from, body]);
  954.       // create related otr object
  955.       if (jsxc.master && !jsxc.otr.objects[bid]) {
  956.          jsxc.otr.create(bid);
  957.       }
  959.       if (!forwarded && mid !== null && request.length && data !== null && (data.sub === 'both' || data.sub === 'from') && type === 'chat') {
  960.          // Send received according to XEP-0184
  961.          jsxc.xmpp.conn.send($msg({
  962.             to: from
  963.          }).c('received', {
  964.             xmlns: 'urn:xmpp:receipts',
  965.             id: mid
  966.          }));
  967.       }
  969.       var attachment;
  970.       if (htmlBody.length === 1) {
  971.          var httpUploadElement = htmlBody.find('a[data-type][data-name][data-size]');
  973.          if (httpUploadElement.length === 1) {
  974.             // deprecated syntax @since 3.2.1
  975.             attachment = {
  976.                type: httpUploadElement.attr('data-type'),
  977.                name: httpUploadElement.attr('data-name'),
  978.                size: httpUploadElement.attr('data-size'),
  979.             };
  981.             if (httpUploadElement.attr('data-thumbnail') && httpUploadElement.attr('data-thumbnail').match(/^\s*data:[a-z]+\/[a-z0-9-+.*]+;base64,[a-z0-9=+/]+$/i)) {
  982.                attachment.thumbnail = httpUploadElement.attr('data-thumbnail');
  983.             }
  985.             if (httpUploadElement.attr('href') && httpUploadElement.attr('href').match(/^https:\/\//)) {
  986.                attachment.data = httpUploadElement.attr('href');
  987.                body = null;
  988.             }
  990.             if (!attachment.type.match(/^[a-z]+\/[a-z0-9-+.*]+$/i) || !attachment.name.match(/^[\s\w.,-]+$/i) || !attachment.size.match(/^\d+$/i)) {
  991.                attachment = undefined;
  993.                jsxc.warn('Invalid file type, name or size.');
  994.             }
  995.          } else if (htmlBody.find('>a').length === 1) {
  996.             var linkElement = htmlBody.find('>a');
  997.             var metaString = '';
  998.             var thumbnail;
  1000.             if (linkElement.find('>img').length === 1) {
  1001.                var imgElement = linkElement.find('>img');
  1002.                var src = imgElement.attr('src') || '';
  1003.                var altString = imgElement.attr('alt') || '';
  1004.                metaString = altString.replace(/^Preview:/, '');
  1006.                if (src.match(/^\s*data:[a-z]+\/[a-z0-9-+.*]+;base64,[a-z0-9=+/]+$/i)) {
  1007.                   thumbnail = src;
  1008.                }
  1009.             } else {
  1010.                metaString = linkElement.text();
  1011.             }
  1013.             var metaMatch = metaString.match(/^([a-z]+\/[a-z0-9-+.*]+)\|(\d+)\|([\s\w.,-]+)/);
  1015.             if (metaMatch) {
  1016.                attachment = {
  1017.                   type: metaMatch[1],
  1018.                   size: metaMatch[2],
  1019.                   name: metaMatch[3],
  1020.                };
  1022.                if (thumbnail) {
  1023.                   attachment.thumbnail = thumbnail;
  1024.                }
  1026.                if (linkElement.attr('href') && linkElement.attr('href').match(/^https?:\/\//)) {
  1027.                   attachment.data = linkElement.attr('href');
  1028.                   body = null;
  1029.                }
  1030.             } else {
  1031.                jsxc.warn('Invalid file type, name or size.');
  1032.             }
  1033.          }
  1034.       }
  1036.       if (jsxc.otr.objects.hasOwnProperty(bid) && body) {
  1037.          // @TODO check for file upload url after decryption
  1038.          jsxc.otr.objects[bid].receiveMsg(body, {
  1039.             _uid: mid,
  1040.             stamp: stamp,
  1041.             forwarded: forwarded,
  1042.             attachment: attachment
  1043.          });
  1044.       } else {
  1045.          jsxc.gui.window.postMessage({
  1046.             _uid: mid,
  1047.             bid: bid,
  1048.             direction: jsxc.Message.IN,
  1049.             msg: body,
  1050.             encrypted: false,
  1051.             forwarded: forwarded,
  1052.             stamp: stamp,
  1053.             attachment: attachment
  1054.          });
  1055.       }
  1057.       // preserve handler
  1058.       return true;
  1059.    },
  1061.    onErrorMessage: function(message) {
  1062.       var bid = jsxc.jidToBid($(message).attr('from'));
  1064.       if (jsxc.gui.window.get(bid).length === 0 || !$(message).attr('id')) {
  1065.          return true;
  1066.       }
  1068.       if ($(message).find('item-not-found').length > 0) {
  1069.          jsxc.gui.window.postMessage({
  1070.             bid: bid,
  1071.             direction: jsxc.Message.SYS,
  1072.             msg: $.t('message_not_send_item-not-found')
  1073.          });
  1074.       } else if ($(message).find('forbidden').length > 0) {
  1075.          jsxc.gui.window.postMessage({
  1076.             bid: bid,
  1077.             direction: jsxc.Message.SYS,
  1078.             msg: $.t('message_not_send_forbidden')
  1079.          });
  1080.       } else if ($(message).find('not-acceptable').length > 0) {
  1081.          jsxc.gui.window.postMessage({
  1082.             bid: bid,
  1083.             direction: jsxc.Message.SYS,
  1084.             msg: $.t('message_not_send_not-acceptable')
  1085.          });
  1086.       } else if ($(message).find('remote-server-not-found').length > 0) {
  1087.          jsxc.gui.window.postMessage({
  1088.             bid: bid,
  1089.             direction: jsxc.Message.SYS,
  1090.             msg: $.t('message_not_send_remote-server-not-found')
  1091.          });
  1092.       } else if ($(message).find('service-unavailable').length > 0) {
  1093.          if ($(message).find('[xmlns="' + Strophe.NS.CHATSTATES + '"]').length === 0) {
  1094.             jsxc.gui.window.postMessage({
  1095.                bid: bid,
  1096.                direction: jsxc.Message.SYS,
  1097.                msg: $.t('message_not_send_resource-unavailable')
  1098.             });
  1099.          }
  1100.       } else {
  1101.          jsxc.gui.window.postMessage({
  1102.             bid: bid,
  1103.             direction: jsxc.Message.SYS,
  1104.             msg: $.t('message_not_send')
  1105.          });
  1106.       }
  1108.       jsxc.debug('error message for ' + bid, $(message).find('error')[0]);
  1110.       return true;
  1111.    },
  1113.    /**
  1114.     * Process message stanzas of type headline.
  1115.     *
  1116.     * @param  {String} stanza Message stanza of type headline
  1117.     * @return {Boolean}
  1118.     */
  1119.    onHeadlineMessage: function(stanza) {
  1120.       stanza = $(stanza);
  1122.       var from = stanza.attr('from');
  1123.       var domain = Strophe.getDomainFromJid(from);
  1125.       if (domain !== from) {
  1126.          if (!jsxc.storage.getUserItem('buddy', jsxc.jidToBid(from))) {
  1127.             return true;
  1128.          }
  1129.       } else if (domain !== Strophe.getDomainFromJid(jsxc.xmpp.conn.jid)) {
  1130.          return true;
  1131.       }
  1133.       var subject = stanza.find('subject:first').text() || $.t('Notification');
  1134.       var body = stanza.find('body:first').text();
  1136.       jsxc.notice.add({
  1137.          msg: subject,
  1138.          description: body,
  1139.          type: (domain === from) ? 'announcement' : null
  1140.       }, 'gui.showNotification', [subject, body, from]);
  1142.       return true;
  1143.    },
  1145.    /**
  1146.     * Respond to version request (XEP-0092).
  1147.     */
  1148.    onVersionRequest: function(stanza) {
  1149.       stanza = $(stanza);
  1151.       var from = stanza.attr('from');
  1152.       var id = stanza.attr('id');
  1154.       var iq = $iq({
  1155.             type: 'result',
  1156.             to: from,
  1157.             id: id
  1158.          }).c('query', {
  1159.             xmlns: Strophe.NS.VERSION
  1160.          }).c('name').t('JSXC').up()
  1161.          .c('version').t(jsxc.version);
  1163.       jsxc.xmpp.conn.sendIQ(iq);
  1165.       return true;
  1166.    },
  1168.    /**
  1169.     * Triggerd if the rid changed
  1170.     *
  1171.     * @param {integer} rid next valid request id
  1172.     * @private
  1173.     */
  1174.    onRidChange: function(rid) {
  1175.       jsxc.storage.setItem('rid', rid);
  1176.    },
  1178.    /**
  1179.     * response to friendship request
  1180.     *
  1181.     * @param {string} from jid from original friendship req
  1182.     * @param {boolean} approve
  1183.     */
  1184.    resFriendReq: function(from, approve) {
  1185.       if (jsxc.master) {
  1186.          jsxc.xmpp.conn.send($pres({
  1187.             to: from,
  1188.             type: (approve) ? 'subscribed' : 'unsubscribed'
  1189.          }));
  1191.          jsxc.storage.removeUserItem('friendReq');
  1192.          jsxc.gui.dialog.close();
  1194.       } else {
  1195.          jsxc.storage.updateUserItem('friendReq', 'approve', approve);
  1196.       }
  1197.    },
  1199.    /**
  1200.     * Add buddy to my friends
  1201.     *
  1202.     * @param {string} username jid
  1203.     * @param {string} alias
  1204.     */
  1205.    addBuddy: function(username, alias) {
  1206.       var bid = jsxc.jidToBid(username);
  1208.       if (jsxc.master) {
  1209.          // add buddy to roster (trigger onRosterChanged)
  1210.          var iq = $iq({
  1211.             type: 'set'
  1212.          }).c('query', {
  1213.             xmlns: 'jabber:iq:roster'
  1214.          }).c('item', {
  1215.             jid: username,
  1216.             name: alias || ''
  1217.          });
  1218.          jsxc.xmpp.conn.sendIQ(iq);
  1220.          // send subscription request to buddy (trigger onRosterChanged)
  1221.          jsxc.xmpp.conn.send($pres({
  1222.             to: username,
  1223.             type: 'subscribe'
  1224.          }));
  1226.          jsxc.storage.removeUserItem('add', bid);
  1227.       } else {
  1228.          jsxc.storage.setUserItem('add', bid, {
  1229.             username: username,
  1230.             alias: alias || null
  1231.          });
  1232.       }
  1233.    },
  1235.    /**
  1236.     * Remove buddy from my friends
  1237.     *
  1238.     * @param {type} jid
  1239.     */
  1240.    removeBuddy: function(jid) {
  1241.       var bid = jsxc.jidToBid(jid);
  1243.       // Shortcut to remove buddy from roster and cancle all subscriptions
  1244.       var iq = $iq({
  1245.          type: 'set'
  1246.       }).c('query', {
  1247.          xmlns: 'jabber:iq:roster'
  1248.       }).c('item', {
  1249.          jid: Strophe.getBareJidFromJid(jid),
  1250.          subscription: 'remove'
  1251.       });
  1252.       jsxc.xmpp.conn.sendIQ(iq);
  1254.       jsxc.gui.roster.purge(bid);
  1255.    },
  1257.    onReceived: function(stanza) {
  1258.       var received = $(stanza).find("received[xmlns='urn:xmpp:receipts']");
  1260.       if (received.length) {
  1261.          var receivedId = received.attr('id');
  1262.          var message = new jsxc.Message(receivedId);
  1264.          message.received();
  1265.       }
  1267.       return true;
  1268.    },
  1270.    /**
  1271.     * Public function to send message.
  1272.     *
  1273.     * @memberOf jsxc.xmpp
  1274.     * @param bid css jid of user
  1275.     * @param msg message
  1276.     * @param uid unique id
  1277.     */
  1278.    sendMessage: function(message) {
  1279.       var bid = message.bid;
  1280.       var msg = message.msg;
  1282.       var mucRoomNames = (jsxc.xmpp.conn.muc && jsxc.xmpp.conn.muc.roomNames) ? jsxc.xmpp.conn.muc.roomNames : [];
  1283.       var isMucBid = mucRoomNames.indexOf(bid) >= 0;
  1285.       if (jsxc.otr.objects.hasOwnProperty(bid) && !isMucBid) {
  1286.          jsxc.otr.objects[bid].sendMsg(msg, message);
  1287.       } else {
  1288.          jsxc.xmpp._sendMessage(jsxc.gui.window.get(bid).data('jid'), msg, message);
  1289.       }
  1290.    },
  1292.    /**
  1293.     * Create message stanza and send it.
  1294.     *
  1295.     * @memberOf jsxc.xmpp
  1296.     * @param jid Jabber id
  1297.     * @param msg Message
  1298.     * @param uid unique id
  1299.     * @private
  1300.     */
  1301.    _sendMessage: function(jid, msg, message) {
  1302.       // @TODO put jid into message object
  1303.       var data = jsxc.storage.getUserItem('buddy', jsxc.jidToBid(jid)) || {};
  1304.       var isBar = (Strophe.getBareJidFromJid(jid) === jid);
  1305.       var type = data.type || 'chat';
  1306.       message = message || {};
  1308.       var xmlMsg = $msg({
  1309.          to: jid,
  1310.          type: type,
  1311.          id: message._uid
  1312.       });
  1314.       if (message.type === jsxc.Message.HTML && msg === message.msg && message.htmlMsg) {
  1315.          xmlMsg.c('body').t(msg);
  1317.          xmlMsg.up().c('html', {
  1318.             xmlns: Strophe.NS.XHTML_IM
  1319.          }).c('body', {
  1320.             xmlns: Strophe.NS.XHTML
  1321.          }).h(message.htmlMsg).up();
  1322.       } else {
  1323.          xmlMsg.c('body').t(msg);
  1324.       }
  1326.       if (jsxc.xmpp.carbons.enabled && msg.match(/^\?OTR/)) {
  1327.          xmlMsg.up().c("private", {
  1328.             xmlns: jsxc.CONST.NS.CARBONS
  1329.          });
  1330.       }
  1332.       if (msg.match(/^\?OTR/)) {
  1333.          xmlMsg.up().c("no-permanent-store", {
  1334.             xmlns: jsxc.CONST.NS.HINTS
  1335.          });
  1336.       }
  1338.       if (type === 'chat' && (isBar || jsxc.xmpp.conn.caps.hasFeatureByJid(jid, Strophe.NS.RECEIPTS))) {
  1339.          // Add request according to XEP-0184
  1340.          xmlMsg.up().c('request', {
  1341.             xmlns: 'urn:xmpp:receipts'
  1342.          });
  1343.       }
  1345.       if (jsxc.xmpp.conn.chatstates && !jsxc.xmpp.chatState.isDisabled()) {
  1346.          // send active event (XEP-0085)
  1347.          xmlMsg.up().c('active', {
  1348.             xmlns: Strophe.NS.CHATSTATES
  1349.          });
  1350.       }
  1352.       jsxc.xmpp.conn.send(xmlMsg);
  1353.    },
  1355.    /**
  1356.     * This function loads a vcard.
  1357.     *
  1358.     * @memberOf jsxc.xmpp
  1359.     * @param bid
  1360.     * @param cb
  1361.     * @param error_cb
  1362.     */
  1363.    loadVcard: function(bid, cb, error_cb) {
  1364.       if (jsxc.master) {
  1365.          jsxc.xmpp.conn.vcard.get(cb, bid, error_cb);
  1366.       } else {
  1367.          jsxc.storage.setUserItem('vcard', bid, 'request:' + (new Date()).getTime());
  1369.          $(document).one('loaded.vcard.jsxc', function(ev, result) {
  1370.             if (result && result.state === 'success') {
  1371.                cb($(result.data).get(0));
  1372.             } else {
  1373.                error_cb();
  1374.             }
  1375.          });
  1376.       }
  1377.    },
  1379.    /**
  1380.     * Retrieves capabilities.
  1381.     *
  1382.     * @memberOf jsxc.xmpp
  1383.     * @param jid
  1384.     * @returns List of known capabilities
  1385.     */
  1386.    getCapabilitiesByJid: function(jid) {
  1387.       if (jsxc.xmpp.conn) {
  1388.          return jsxc.xmpp.conn.caps.getCapabilitiesByJid(jid);
  1389.       }
  1391.       var jidVerIndex = JSON.parse(localStorage.getItem('strophe.caps._jidVerIndex')) || {};
  1392.       var knownCapabilities = JSON.parse(localStorage.getItem('strophe.caps._knownCapabilities')) || {};
  1394.       if (jidVerIndex[jid]) {
  1395.          return knownCapabilities[jidVerIndex[jid]];
  1396.       }
  1398.       return null;
  1399.    },
  1401.    /**
  1402.     * Test if jid has given features
  1403.     *
  1404.     * @param  {string}   jid     Jabber id
  1405.     * @param  {string[]} feature Single feature or list of features
  1406.     * @param  {Function} cb      Called with the result as first param.
  1407.     * @return {boolean}          True, if jid has all given features. Null, if we do not know it currently.
  1408.     */
  1409.    hasFeatureByJid: function(jid, feature, cb) {
  1410.       var conn = jsxc.xmpp.conn;
  1411.       cb = cb || function() {};
  1413.       if (!feature) {
  1414.          return false;
  1415.       }
  1417.       if (!$.isArray(feature)) {
  1418.          feature = $.makeArray(feature);
  1419.       }
  1421.       var check = function(knownCapabilities) {
  1422.          if (!knownCapabilities) {
  1423.             return null;
  1424.          }
  1425.          var i;
  1426.          for (i = 0; i < feature.length; i++) {
  1427.             if (knownCapabilities['features'].indexOf(feature[i]) < 0) {
  1428.                return false;
  1429.             }
  1430.          }
  1431.          return true;
  1432.       };
  1434.       if (conn.caps._jidVerIndex[jid] && conn.caps._knownCapabilities[conn.caps._jidVerIndex[jid]]) {
  1435.          var hasFeature = check(conn.caps._knownCapabilities[conn.caps._jidVerIndex[jid]]);
  1436.          cb(hasFeature);
  1438.          return hasFeature;
  1439.       }
  1441.       $(document).on('strophe.caps', function(ev, j, capabilities) {
  1442.          if (j === jid) {
  1443.             cb(check(capabilities));
  1445.             $(document).off(ev);
  1446.          }
  1447.       });
  1449.       return null;
  1450.    }
  1451. };
  1453. /**
  1454.  * Handle carbons (XEP-0280);
  1455.  *
  1456.  * @namespace jsxc.xmpp.carbons
  1457.  */
  1458. jsxc.xmpp.carbons = {
  1459.    enabled: false,
  1461.    /**
  1462.     * Enable carbons.
  1463.     *
  1464.     * @memberOf jsxc.xmpp.carbons
  1465.     * @param cb callback
  1466.     */
  1467.    enable: function(cb) {
  1468.       var iq = $iq({
  1469.          type: 'set'
  1470.       }).c('enable', {
  1471.          xmlns: jsxc.CONST.NS.CARBONS
  1472.       });
  1474.       jsxc.xmpp.conn.sendIQ(iq, function() {
  1475.          jsxc.xmpp.carbons.enabled = true;
  1477.          jsxc.debug('Carbons enabled');
  1479.          if (cb) {
  1480.             cb.call(this);
  1481.          }
  1482.       }, function(stanza) {
  1483.          jsxc.warn('Could not enable carbons', stanza);
  1484.       });
  1485.    },
  1487.    /**
  1488.     * Disable carbons.
  1489.     *
  1490.     * @memberOf jsxc.xmpp.carbons
  1491.     * @param cb callback
  1492.     */
  1493.    disable: function(cb) {
  1494.       var iq = $iq({
  1495.          type: 'set'
  1496.       }).c('disable', {
  1497.          xmlns: jsxc.CONST.NS.CARBONS
  1498.       });
  1500.       jsxc.xmpp.conn.sendIQ(iq, function() {
  1501.          jsxc.xmpp.carbons.enabled = false;
  1503.          jsxc.debug('Carbons disabled');
  1505.          if (cb) {
  1506.             cb.call(this);
  1507.          }
  1508.       }, function(stanza) {
  1509.          jsxc.warn('Could not disable carbons', stanza);
  1510.       });
  1511.    },
  1513.    /**
  1514.     * Enable/Disable carbons depending on options key.
  1515.     *
  1516.     * @memberOf jsxc.xmpp.carbons
  1517.     * @param err error message
  1518.     */
  1519.    refresh: function(err) {
  1520.       if (err === false) {
  1521.          return;
  1522.       }
  1524.       if (jsxc.options.get('carbons').enable) {
  1525.          return jsxc.xmpp.carbons.enable();
  1526.       }
  1528.       return jsxc.xmpp.carbons.disable();
  1529.    }
  1530. };