0.6.3

Fix params getting replaced on register calls

CHANGELOG.md

@@ -1,3 +1,124 @@
+Changes in [0.6.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.3) (2016-10-12)
+================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.6.2...v0.6.3)
+
+Breaking Changes
+----------------
+ * Add a 'RECONNECTING' state to the sync states. This is an additional state
+   between 'SYNCING' and 'ERROR', so most clients should not notice.
+
+Other Changes
+----------------
+ * Fix params getting replaced on register calls
+   [\#233](https://github.com/matrix-org/matrix-js-sdk/pull/233)
+ * Fix potential 30s delay on reconnect
+   [\#232](https://github.com/matrix-org/matrix-js-sdk/pull/232)
+ * uploadContent: Attempt some consistency between browser and node
+   [\#230](https://github.com/matrix-org/matrix-js-sdk/pull/230)
+ * Fix error handling on uploadContent
+   [\#229](https://github.com/matrix-org/matrix-js-sdk/pull/229)
+ * Fix uploadContent for node.js
+   [\#226](https://github.com/matrix-org/matrix-js-sdk/pull/226)
+ * Don't emit ERROR until a keepalive poke fails
+   [\#223](https://github.com/matrix-org/matrix-js-sdk/pull/223)
+ * Function to get the fallback url for interactive auth
+   [\#224](https://github.com/matrix-org/matrix-js-sdk/pull/224)
+ * Revert "Handle the first /sync failure differently."
+   [\#222](https://github.com/matrix-org/matrix-js-sdk/pull/222)
+
+Changes in [0.6.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.2) (2016-10-05)
+================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.6.1...v0.6.2)
+
+ * Check dependencies aren't on develop in release.sh
+   [\#221](https://github.com/matrix-org/matrix-js-sdk/pull/221)
+ * Fix checkTurnServers leak on logout
+   [\#220](https://github.com/matrix-org/matrix-js-sdk/pull/220)
+ * Fix leak of file upload objects
+   [\#219](https://github.com/matrix-org/matrix-js-sdk/pull/219)
+ * crypto: remove duplicate code
+   [\#218](https://github.com/matrix-org/matrix-js-sdk/pull/218)
+ * Add API for 3rd party location lookup
+   [\#217](https://github.com/matrix-org/matrix-js-sdk/pull/217)
+ * Handle the first /sync failure differently.
+   [\#216](https://github.com/matrix-org/matrix-js-sdk/pull/216)
+
+Changes in [0.6.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.1) (2016-09-21)
+================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.6.0...v0.6.1)
+
+ * Fix the ed25519 key checking
+   [\#215](https://github.com/matrix-org/matrix-js-sdk/pull/215)
+ * Add MatrixClient.getEventSenderDeviceInfo()
+   [\#214](https://github.com/matrix-org/matrix-js-sdk/pull/214)
+
+Changes in [0.6.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.0) (2016-09-21)
+================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.5.6...v0.6.0)
+
+ * Pull user device list on join
+   [\#212](https://github.com/matrix-org/matrix-js-sdk/pull/212)
+ * Fix sending of oh_hais on bad sessions
+   [\#213](https://github.com/matrix-org/matrix-js-sdk/pull/213)
+ * Support /publicRooms pagination
+   [\#211](https://github.com/matrix-org/matrix-js-sdk/pull/211)
+ * Update the olm library version to 1.3.0
+   [\#205](https://github.com/matrix-org/matrix-js-sdk/pull/205)
+ * Comment what the logic in uploadKeys does
+   [\#209](https://github.com/matrix-org/matrix-js-sdk/pull/209)
+ * Include keysProved and keysClaimed in the local echo for events we send.
+   [\#210](https://github.com/matrix-org/matrix-js-sdk/pull/210)
+ * Check if we need to upload new one-time keys every 10 minutes
+   [\#208](https://github.com/matrix-org/matrix-js-sdk/pull/208)
+ * Reset oneTimeKey to null on each loop iteration.
+   [\#207](https://github.com/matrix-org/matrix-js-sdk/pull/207)
+ * Add getKeysProved and getKeysClaimed methods to MatrixEvent.
+   [\#206](https://github.com/matrix-org/matrix-js-sdk/pull/206)
+ * Send a 'm.new_device' when we get a message for an unknown group session
+   [\#204](https://github.com/matrix-org/matrix-js-sdk/pull/204)
+ * Introduce EventTimelineSet, filtered timelines and global notif timeline.
+   [\#196](https://github.com/matrix-org/matrix-js-sdk/pull/196)
+ * Wrap the crypto event handlers in try/catch blocks
+   [\#203](https://github.com/matrix-org/matrix-js-sdk/pull/203)
+ * Show warnings on to-device decryption fail
+   [\#202](https://github.com/matrix-org/matrix-js-sdk/pull/202)
+ * s/Displayname/DisplayName/
+   [\#201](https://github.com/matrix-org/matrix-js-sdk/pull/201)
+ * OH HAI
+   [\#200](https://github.com/matrix-org/matrix-js-sdk/pull/200)
+ * Share the current ratchet with new members
+   [\#199](https://github.com/matrix-org/matrix-js-sdk/pull/199)
+ * Move crypto bits into a subdirectory
+   [\#198](https://github.com/matrix-org/matrix-js-sdk/pull/198)
+ * Refactor event handling in Crypto
+   [\#197](https://github.com/matrix-org/matrix-js-sdk/pull/197)
+ * Don't create Olm sessions proactively
+   [\#195](https://github.com/matrix-org/matrix-js-sdk/pull/195)
+ * Use to-device events for key sharing
+   [\#194](https://github.com/matrix-org/matrix-js-sdk/pull/194)
+ * README: callbacks deprecated
+   [\#193](https://github.com/matrix-org/matrix-js-sdk/pull/193)
+ * Fix sender verification for megolm messages
+   [\#192](https://github.com/matrix-org/matrix-js-sdk/pull/192)
+ * Use `ciphertext` instead of `body` in megolm events
+   [\#191](https://github.com/matrix-org/matrix-js-sdk/pull/191)
+ * Add debug methods to get the state of OlmSessions
+   [\#189](https://github.com/matrix-org/matrix-js-sdk/pull/189)
+ * MatrixClient.getStoredDevicesForUser
+   [\#190](https://github.com/matrix-org/matrix-js-sdk/pull/190)
+ * Olm-related cleanups
+   [\#188](https://github.com/matrix-org/matrix-js-sdk/pull/188)
+ * Update to fixed olmlib
+   [\#187](https://github.com/matrix-org/matrix-js-sdk/pull/187)
+ * always play audio out of the remoteAudioElement if it exists.
+   [\#186](https://github.com/matrix-org/matrix-js-sdk/pull/186)
+ * Fix exceptions where HTMLMediaElement loads and plays race
+   [\#185](https://github.com/matrix-org/matrix-js-sdk/pull/185)
+ * Reset megolm session when people join/leave the room
+   [\#183](https://github.com/matrix-org/matrix-js-sdk/pull/183)
+ * Fix exceptions when dealing with redactions
+   [\#184](https://github.com/matrix-org/matrix-js-sdk/pull/184)
+
 Changes in [0.5.6](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.6) (2016-08-28)
 ================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.5.5...v0.5.6)

lib/base-apis.js

@@ -136,10 +136,12 @@ MatrixBaseApis.prototype.register = function(
     var params = {
         auth: auth
     };
-    if (username !== undefined) { params.username = username; }
-    if (password !== undefined) { params.password = password; }
-    if (bindEmail !== undefined) { params.bind_email = bindEmail; }
-    if (guestAccessToken !== undefined) { params.guest_access_token = guestAccessToken; }
+    if (username !== undefined && username !== null) { params.username = username; }
+    if (password !== undefined && password !== null) { params.password = password; }
+    if (bindEmail !== undefined && bindEmail !== null) { params.bind_email = bindEmail; }
+    if (guestAccessToken !== undefined && guestAccessToken !== null) {
+        params.guest_access_token = guestAccessToken;
+    }
 
     return this.registerRequest(params, undefined, callback);
 };
@@ -290,6 +292,23 @@ MatrixBaseApis.prototype.deactivateAccount = function(auth, callback) {
     );
 };
 
+/**
+ * Get the fallback URL to use for unknown interactive-auth stages.
+ *
+ * @param {string} loginType     the type of stage being attempted
+ * @param {string} authSessionId the auth session ID provided by the homeserver
+ *
+ * @return {string} HS URL to hit to for the fallback interface
+ */
+MatrixBaseApis.prototype.getFallbackAuthUrl = function(loginType, authSessionId) {
+    var path = utils.encodeUri("/auth/$loginType/fallback/web", {
+        $loginType: loginType,
+    });
+
+    return this._http.getUrl(path, {
+        session: authSessionId,
+    }, httpApi.PREFIX_R0);
+};
 
 // Room operations
 // ===============
@@ -415,12 +434,39 @@ MatrixBaseApis.prototype.roomInitialSync = function(roomId, limit, callback) {
 // =========================
 
 /**
+ * @param {string} options.server The remote server to query for the room list.
+ *                                Optional. If unspecified, get the local home
+ *                                server's public room list.
+ * @param {number} options.limit Maximum number of entries to return
+ * @param {string} options.since Token to paginate from
+ * @param {object} options.filter Filter parameters
+ * @param {string} options.filter.generic_search_term String to search for
  * @param {module:client.callback} callback Optional.
  * @return {module:client.Promise} Resolves: TODO
  * @return {module:http-api.MatrixError} Rejects: with an error response.
  */
-MatrixBaseApis.prototype.publicRooms = function(callback) {
-    return this._http.authedRequest(callback, "GET", "/publicRooms");
+MatrixBaseApis.prototype.publicRooms = function(options, callback) {
+    if (typeof(options) == 'function') {
+        callback = options;
+        options = {};
+    }
+    if (options === undefined) {
+        options = {};
+    }
+
+    var query_params = {};
+    if (options.server) {
+        query_params.server = options.server;
+        delete options.server;
+    }
+
+    if (Object.keys(options).length === 0 && Object.keys(query_params).length === 0) {
+        return this._http.authedRequest(callback, "GET", "/publicRooms");
+    } else {
+        return this._http.authedRequest(
+            callback, "POST", "/publicRooms", query_params, options
+        );
+    }
 };
 
 /**
@@ -530,13 +576,38 @@ MatrixBaseApis.prototype.setRoomDirectoryVisibility =
 
 /**
  * Upload a file to the media repository on the home server.
- * @param {File} file object
- * @param {module:client.callback} callback Optional.
- * @return {module:client.Promise} Resolves: TODO
- * @return {module:http-api.MatrixError} Rejects: with an error response.
+ *
+ * @param {object} file The object to upload. On a browser, something that
+ *   can be sent to XMLHttpRequest.send (typically a File).  Under node.js,
+ *   a a Buffer, String or ReadStream.
+ *
+ * @param {object} opts  options object
+ *
+ * @param {string=} opts.name   Name to give the file on the server. Defaults
+ *   to <tt>file.name</tt>.
+ *
+ * @param {string=} opts.type   Content-type for the upload. Defaults to
+ *   <tt>file.type</tt>, or <tt>applicaton/octet-stream</tt>.
+ *
+ * @param {boolean=} opts.rawResponse Return the raw body, rather than
+ *   parsing the JSON. Defaults to false (except on node.js, where it
+ *   defaults to true for backwards compatibility).
+ *
+ * @param {boolean=} opts.onlyContentUri Just return the content URI,
+ *   rather than the whole body. Defaults to false (except on browsers,
+ *   where it defaults to true for backwards compatibility). Ignored if
+ *   opts.rawResponse is true.
+ *
+ * @param {Function=} opts.callback Deprecated. Optional. The callback to
+ *    invoke on success/failure. See the promise return values for more
+ *    information.
+ *
+ * @return {module:client.Promise} Resolves to response object, as
+ *    determined by this.opts.onlyData, opts.rawResponse, and
+ *    opts.onlyContentUri.  Rejects with an error (usually a MatrixError).
  */
-MatrixBaseApis.prototype.uploadContent = function(file, callback) {
-    return this._http.uploadContent(file, callback);
+MatrixBaseApis.prototype.uploadContent = function(file, opts) {
+    return this._http.uploadContent(file, opts);
 };
 
 /**
@@ -1012,6 +1083,39 @@ MatrixBaseApis.prototype.sendToDevice = function(
     );
 };
 
+// Third party Lookup API
+// ======================
+
+/**
+ * Get the third party protocols that can be reached using
+ * this HS
+ * @return {module:client.Promise} Resolves to the result object
+ */
+MatrixBaseApis.prototype.getThirdpartyProtocols = function() {
+    return this._http.authedRequestWithPrefix(
+        undefined, "GET", "/thirdparty/protocols", undefined, undefined,
+        httpApi.PREFIX_UNSTABLE
+    );
+};
+
+/**
+ * Get information on how a specific place on a third party protocol
+ * may be reached.
+ * @param {string} protocol The protocol given in getThirdpartyProtocols()
+ * @param {object} params Protocol-specific parameters, as given in th
+ *                        response to getThirdpartyProtocols()
+ * @return {module:client.Promise} Resolves to the result object
+ */
+MatrixBaseApis.prototype.getThirdpartyLocation = function(protocol, params) {
+    var path = utils.encodeUri("/thirdparty/location/$protocol", {
+        $protocol: protocol
+    });
+
+    return this._http.authedRequestWithPrefix(
+        undefined, "GET", path, params, undefined,
+        httpApi.PREFIX_UNSTABLE
+    );
+};
 
 /**
  * MatrixBaseApis object

lib/client.js

@@ -156,6 +156,8 @@ function MatrixClient(opts) {
             opts.sessionStore,
             userId, this.deviceId
         );
+
+        this.olmVersion = Crypto.getOlmVersion();
     }
 }
 utils.inherits(MatrixClient, EventEmitter);
@@ -399,6 +401,21 @@ function _setDeviceVerification(client, userId, deviceId, verified, blocked) {
     client.emit("deviceVerificationChanged", userId, deviceId);
 }
 
+/**
+ * Get e2e information on the device that sent an event
+ *
+ * @param {MatrixEvent} event event to be checked
+ *
+ * @return {module:crypto/deviceinfo?}
+ */
+MatrixClient.prototype.getEventSenderDeviceInfo = function(event) {
+    if (!this._crypto) {
+        return null;
+    }
+
+    return this._crypto.getEventSenderDeviceInfo(event);
+};
+
 /**
  * Check if the sender of an event is verified
  *
@@ -408,21 +425,11 @@ function _setDeviceVerification(client, userId, deviceId, verified, blocked) {
  * {@link module:client~MatrixClient#setDeviceVerified|setDeviceVerified}.
  */
 MatrixClient.prototype.isEventSenderVerified = function(event) {
-    if (!this._crypto) {
+    var device = this.getEventSenderDeviceInfo(event);
+    if (!device) {
         return false;
     }
-
-    var sender_key = event.getSenderKey();
-
-    if (!sender_key) {
-        return false;
-    }
-
-    var algorithm = event.getWireContent().algorithm;
-
-    return this._crypto.isSenderKeyVerified(
-        event.getSender(), algorithm, sender_key
-    );
+    return device.isVerified();
 };
 
 /**
@@ -458,32 +465,38 @@ MatrixClient.prototype.isRoomEncrypted = function(roomId) {
  * @param {MatrixClient} client
  * @param {object} raw event
  *
- * @return {object} decrypted payload (with properties 'type', 'content')
+ * @return {MatrixEvent}
  */
-function _decryptMessage(client, event) {
+function _decryptEvent(client, event) {
     if (!client._crypto) {
         return _badEncryptedMessage(event, "**Encryption not enabled**");
     }
 
+    var decryptionResult;
     try {
-        return client._crypto.decryptEvent(event);
+        decryptionResult = client._crypto.decryptEvent(event);
     } catch (e) {
         if (!(e instanceof Crypto.DecryptionError)) {
             throw e;
         }
         return _badEncryptedMessage(event, "**" + e.message + "**");
     }
+    return new MatrixEvent(
+        event, decryptionResult.payload,
+        decryptionResult.keysProved,
+        decryptionResult.keysClaimed
+    );
 }
 
 function _badEncryptedMessage(event, reason) {
-    return {
+    return new MatrixEvent(event, {
         type: "m.room.message",
         content: {
             msgtype: "m.bad.encrypted",
             body: reason,
             content: event.content,
         },
-    };
+    });
 }
 
 // Room ops
@@ -2497,6 +2510,11 @@ MatrixClient.prototype.startClient = function(opts) {
 
     if (this._crypto) {
         this._crypto.uploadKeys(5).done();
+        var tenMinutes = 1000 * 60 * 10;
+        var self = this;
+        this._uploadIntervalID = global.setInterval(function() {
+            self._crypto.uploadKeys(5).done();
+        }, tenMinutes);
     }
 
     // periodically poll for turn servers if we support voip
@@ -2522,6 +2540,10 @@ MatrixClient.prototype.stopClient = function() {
         this._syncApi.stop();
         this._syncApi = null;
     }
+    if (this._crypto) {
+        global.clearInterval(this._uploadIntervalID);
+    }
+    global.clearTimeout(this._checkTurnServersTimeoutID);
 };
 
 function setupCallEventHandler(client) {
@@ -2741,13 +2763,15 @@ function checkTurnServers(client) {
             };
             client._turnServers = [servers];
             // re-fetch when we're about to reach the TTL
-            setTimeout(function() { checkTurnServers(client); },
-                (res.ttl || (60 * 60)) * 1000 * 0.9
-            );
+            client._checkTurnServersTimeoutID =
+                setTimeout(function() { checkTurnServers(client); },
+                           (res.ttl || (60 * 60)) * 1000 * 0.9
+                          );
         }
     }, function(err) {
         console.error("Failed to get TURN URIs");
-        setTimeout(function() { checkTurnServers(client); }, 60000);
+        client._checkTurnServersTimeoutID =
+            setTimeout(function() { checkTurnServers(client); }, 60000);
     });
 }
 
@@ -2767,12 +2791,10 @@ function _resolve(callback, defer, res) {
 
 function _PojoToMatrixEventMapper(client) {
     function mapper(plainOldJsObject) {
-        var clearData;
         if (plainOldJsObject.type === "m.room.encrypted") {
-            clearData = _decryptMessage(client, plainOldJsObject);
+            return _decryptEvent(client, plainOldJsObject);
         }
-        var matrixEvent = new MatrixEvent(plainOldJsObject, clearData);
-        return matrixEvent;
+        return new MatrixEvent(plainOldJsObject);
     }
     return mapper;
 }
@@ -2845,6 +2867,9 @@ module.exports.CRYPTO_ENABLED = CRYPTO_ENABLED;
  * the server for updates. This may be called multiple times even if the state is
  * already ERROR. <i>This is the equivalent of "syncError" in the previous
  * API.</i></li>
+ * <li>RECONNECTING: The sync connedtion has dropped, but not in a way that should
+ * be considered erroneous.
+ * </li>
  * <li>STOPPED: The client has stopped syncing with server due to stopClient
  * being called.
  * </li>
@@ -2854,8 +2879,10 @@ module.exports.CRYPTO_ENABLED = CRYPTO_ENABLED;
  *                                          +---->STOPPED
  *                                          |
  *              +----->PREPARED -------> SYNCING <--+
- *              |        ^                  |       |
- *   null ------+        |  +---------------+       |
+ *              |        ^                  ^       |
+ *              |        |                  |       |
+ *              |        |                  V       |
+ *   null ------+        |  +-RECONNECTING<-+       |
  *              |        |  V                       |
  *              +------->ERROR ---------------------+
  *

lib/crypto/OlmDevice.js

@@ -72,6 +72,14 @@ function _initialise_account(sessionStore, pickleKey, account) {
     sessionStore.storeEndToEndAccount(pickled);
 }
 
+/**
+ * @return {array} The version of Olm.
+ */
+OlmDevice.getOlmVersion = function() {
+    return Olm.get_library_version();
+};
+
+
 /**
  * extract our OlmAccount from the session store and call the given function
  *
@@ -252,7 +260,8 @@ OlmDevice.prototype.createOutboundSession = function(
  * @param {number} message_type  message_type field from the received message (must be 0)
  * @param {string} ciphertext base64-encoded body from the received message
  *
- * @return {string} decrypted payload
+ * @return {{payload: string, session_id: string}} decrypted payload, and
+ *     session id of new session
  *
  * @raises {Error} if the received message was not valid (for instance, it
  *     didn't use a valid one-time key).
@@ -276,7 +285,10 @@ OlmDevice.prototype.createInboundSession = function(
 
             self._saveSession(theirDeviceIdentityKey, session);
 
-            return payloadString;
+            return {
+                payload: payloadString,
+                session_id: session.session_id(),
+            };
         } finally {
             session.free();
         }
@@ -378,12 +390,7 @@ OlmDevice.prototype.encryptMessage = function(
  * @param {number} message_type  message_type field from the received message
  * @param {string} ciphertext base64-encoded body from the received message
  *
- * @return {object} Result, with keys <ul>
- *   <li><tt>matchesInbound</tt>: (boolean): true if the message was a pre-key
- *      message which matched an existing inbound session.</li>
- *   <li><tt>payload</tt>: (string): decrypted payload; null if the received
- *     message was not valid (for instance, it did not match this session).</li>
- * </ul>
+ * @return {string} decrypted payload.
  */
 OlmDevice.prototype.decryptMessage = function(
     theirDeviceIdentityKey, sessionId, message_type, ciphertext
@@ -391,28 +398,38 @@ OlmDevice.prototype.decryptMessage = function(
     var self = this;
 
     return this._getSession(theirDeviceIdentityKey, sessionId, function(session) {
-        var matchesInbound = (message_type === 0 &&
-                              session.matches_inbound(ciphertext));
-
-        var payloadString = null;
-        try {
-            payloadString = session.decrypt(message_type, ciphertext);
-        } catch (e) {
-            console.log(
-                "Failed to decrypt with an existing session: " + e.message
-            );
-            // return null as the payload
-        }
-
+        var payloadString = session.decrypt(message_type, ciphertext);
         self._saveSession(theirDeviceIdentityKey, session);
 
-        return {
-            matchesInbound: matchesInbound,
-            payload: payloadString,
-        };
+        return payloadString;
     });
 };
 
+/**
+ * Determine if an incoming messages is a prekey message matching an existing session
+ *
+ * @param {string} theirDeviceIdentityKey Curve25519 identity key for the
+ *     remote device
+ * @param {string} sessionId  the id of the active session
+ * @param {number} message_type  message_type field from the received message
+ * @param {string} ciphertext base64-encoded body from the received message
+ *
+ * @return {boolean} true if the received message is a prekey message which matches
+ *    the given session.
+ */
+OlmDevice.prototype.matchesSession = function(
+    theirDeviceIdentityKey, sessionId, message_type, ciphertext
+) {
+    if (message_type !== 0) {
+        return false;
+    }
+
+    return this._getSession(theirDeviceIdentityKey, sessionId, function(session) {
+        return session.matches_inbound(ciphertext);
+    });
+};
+
+
 
 // Outbound group session
 // ======================
@@ -514,21 +531,23 @@ OlmDevice.prototype.getOutboundGroupSessionKey = function(sessionId) {
  * store an InboundGroupSession in the session store
  *
  * @param {string} roomId
- * @param {string} senderKey
+ * @param {string} senderCurve25519Key
  * @param {string} sessionId
  * @param {Olm.InboundGroupSession} session
+ * @param {object} keysClaimed Other keys the sender claims.
  * @private
  */
 OlmDevice.prototype._saveInboundGroupSession = function(
-    roomId, senderKey, sessionId, session
+    roomId, senderCurve25519Key, sessionId, session, keysClaimed
 ) {
     var r = {
         room_id: roomId,
         session: session.pickle(this._pickleKey),
+        keysClaimed: keysClaimed,
     };
 
     this._sessionStore.storeEndToEndInboundGroupSession(
-        senderKey, sessionId, JSON.stringify(r)
+        senderCurve25519Key, sessionId, JSON.stringify(r)
     );
 };
 
@@ -538,9 +557,15 @@ OlmDevice.prototype._saveInboundGroupSession = function(
  * @param {string} roomId
  * @param {string} senderKey
  * @param {string} sessionId
- * @param {function} func
- * @return {object} result of func
+ * @param {function(Olm.InboundGroupSession, Object<string, string>): T} func
+ *   function to call. Second argument is the map of keys claimed by the session.
+ *
+ * @return {null} the sessionId is unknown
+ *
+ * @return {T} result of func
+ *
  * @private
+ * @template {T}
  */
 OlmDevice.prototype._getInboundGroupSession = function(
     roomId, senderKey, sessionId, func
@@ -550,7 +575,7 @@ OlmDevice.prototype._getInboundGroupSession = function(
     );
 
     if (r === null) {
-        throw new Error("Unknown inbound group session id");
+        return null;
     }
 
     r = JSON.parse(r);
@@ -567,7 +592,7 @@ OlmDevice.prototype._getInboundGroupSession = function(
     var session = new Olm.InboundGroupSession();
     try {
         session.unpickle(this._pickleKey, r.session);
-        return func(session);
+        return func(session, r.keysClaimed || {});
     } finally {
         session.free();
     }
@@ -579,17 +604,24 @@ OlmDevice.prototype._getInboundGroupSession = function(
  * @param {string} roomId     room in which this session will be used
  * @param {string} senderKey  base64-encoded curve25519 key of the sender
  * @param {string} sessionId  session identifier
- * @param {string} sessionKey base64-encoded secret key at index chainIndex
- * @param {number} chainIndex index at which sessionKey applies
+ * @param {string} sessionKey base64-encoded secret key
+ * @param {Object<string, string>} keysClaimed Other keys the sender claims.
  */
 OlmDevice.prototype.addInboundGroupSession = function(
-    roomId, senderKey, sessionId, sessionKey, chainIndex
+    roomId, senderKey, sessionId, sessionKey, keysClaimed
 ) {
     var self = this;
     var session = new Olm.InboundGroupSession();
     try {
-        session.create(chainIndex, sessionKey);
-        self._saveInboundGroupSession(roomId, senderKey, sessionId, session);
+        session.create(sessionKey);
+        if (sessionId != session.session_id()) {
+            throw new Error(
+                "Mismatched group session ID from senderKey: " + senderKey
+            );
+        }
+        self._saveInboundGroupSession(
+            roomId, senderKey, sessionId, session, keysClaimed
+        );
     } finally {
         session.free();
     }
@@ -603,19 +635,31 @@ OlmDevice.prototype.addInboundGroupSession = function(
  * @param {string} sessionId session identifier
  * @param {string} body      base64-encoded body of the encrypted message
  *
- * @return {string} plaintext
+ * @return {null} the sessionId is unknown
+ *
+ * @return {{result: string, keysProved: Object<string, string>, keysClaimed:
+ *    Object<string, string>}} result
  */
 OlmDevice.prototype.decryptGroupMessage = function(
     roomId, senderKey, sessionId, body
 ) {
     var self = this;
 
-    function decrypt(session) {
+    function decrypt(session, keysClaimed) {
         var res = session.decrypt(body);
+
+        // the sender must have had the senderKey to persuade us to save the
+        // session.
+        var keysProved = {curve25519: senderKey};
+
         self._saveInboundGroupSession(
-            roomId, senderKey, sessionId, session
+            roomId, senderKey, sessionId, session, keysClaimed
         );
-        return res;
+        return {
+            result: res,
+            keysClaimed: keysClaimed,
+            keysProved: keysProved,
+        };
     }
 
     return this._getInboundGroupSession(

lib/crypto/algorithms/base.js

@@ -117,7 +117,8 @@ module.exports.DecryptionAlgorithm = DecryptionAlgorithm;
  *
  * @param {object} event raw event
  *
- * @return {object} decrypted payload (with properties 'type', 'content')
+ * @return {null} if the event referred to an unknown megolm session
+ * @return {module:crypto.DecryptionResult} decryption result
  *
  * @throws {module:crypto/algorithms/base.DecryptionError} if there is a
  *   problem decrypting the event

lib/crypto/algorithms/megolm.js

@@ -124,7 +124,7 @@ MegolmEncryption.prototype._prepareNewSession = function(room) {
 
     this._olmDevice.addInboundGroupSession(
         this._roomId, this._olmDevice.deviceCurve25519Key, session_id,
-        key.key, key.chain_index
+        key.key, {ed25519: this._olmDevice.deviceEd25519Key}
     );
 
     // we're going to share the key with all current members of the room,
@@ -169,7 +169,11 @@ MegolmEncryption.prototype._prepareNewSession = function(room) {
  * @private
  *
  * @param {string} session_id
+ *
  * @param {Object<string, Object<string, boolean>|boolean>} shareMap
+ *    Map from userid to either: true (meaning this is a new user in the room,
+ *    so all of his devices need the keys); or a map from deviceid to true
+ *    (meaning this user has one or more new devices, which need the keys).
  *
  * @return {module:client.Promise} Promise which resolves once the key sharing
  *     message has been sent.
@@ -189,6 +193,9 @@ MegolmEncryption.prototype._shareKeyWithDevices = function(session_id, shareMap)
         }
     };
 
+    // we downloaded the user's device list when they joined the room, or when
+    // the new device announced itself, so there is no need to do so now.
+
     return self._crypto.ensureOlmSessionsForUsers(
         utils.keys(shareMap)
     ).then(function(devicemap) {
@@ -201,10 +208,10 @@ MegolmEncryption.prototype._shareKeyWithDevices = function(session_id, shareMap)
             }
 
             var devicesToShareWith = shareMap[userId];
-            var deviceInfos = devicemap[userId];
+            var sessionResults = devicemap[userId];
 
-            for (var deviceId in deviceInfos) {
-                if (!deviceInfos.hasOwnProperty(deviceId)) {
+            for (var deviceId in sessionResults) {
+                if (!sessionResults.hasOwnProperty(deviceId)) {
                     continue;
                 }
 
@@ -215,11 +222,27 @@ MegolmEncryption.prototype._shareKeyWithDevices = function(session_id, shareMap)
                     continue;
                 }
 
+                var sessionResult = sessionResults[deviceId];
+                if (!sessionResult.sessionId) {
+                    // no session with this device, probably because there
+                    // were no one-time keys.
+                    //
+                    // we could send them a to_device message anyway, as a
+                    // signal that they have missed out on the key sharing
+                    // message because of the lack of keys, but there's not
+                    // much point in that really; it will mostly serve to clog
+                    // up to_device inboxes.
+                    //
+                    // ensureOlmSessionsForUsers has already done the logging,
+                    // so just skip it.
+                    continue;
+                }
+
                 console.log(
                     "sharing keys with device " + userId + ":" + deviceId
                 );
 
-                var deviceInfo = deviceInfos[deviceId].device;
+                var deviceInfo = sessionResult.device;
 
                 if (!contentMap[userId]) {
                     contentMap[userId] = {};
@@ -272,6 +295,9 @@ MegolmEncryption.prototype.encryptMessage = function(room, eventType, content) {
             sender_key: self._olmDevice.deviceCurve25519Key,
             ciphertext: ciphertext,
             session_id: session_id,
+             // Include our device ID so that recipients can send us a
+             // m.new_device message if they don't have our session key.
+            device_id: self._deviceId,
         };
 
         return encryptedContent;
@@ -289,8 +315,7 @@ MegolmEncryption.prototype.onRoomMembership = function(event, member, oldMembers
     var newMembership = member.membership;
 
     if (newMembership === 'join') {
-        // new member in the room.
-        this._devicesPendingKeyShare[member.userId] = true;
+        this._onNewRoomMember(member.userId);
         return;
     }
 
@@ -315,6 +340,23 @@ MegolmEncryption.prototype.onRoomMembership = function(event, member, oldMembers
     }
 };
 
+/**
+ * handle a new user joining a room
+ *
+ * @param {string} userId   new member
+ */
+MegolmEncryption.prototype._onNewRoomMember = function(userId) {
+    // make sure we have a list of this user's devices. We are happy to use a
+    // cached version here: we assume that if we already have a list of the
+    // user's devices, then we already share an e2e room with them, which means
+    // that they will have announced any new devices via an m.new_device.
+    this._crypto.downloadKeys([userId], false).done();
+
+    // also flag this user up for needing a keyshare.
+    this._devicesPendingKeyShare[userId] = true;
+};
+
+
 /**
  * @inheritdoc
  *
@@ -356,7 +398,8 @@ utils.inherits(MegolmDecryption, base.DecryptionAlgorithm);
  *
  * @param {object} event raw event
  *
- * @return {object} decrypted payload (with properties 'type', 'content')
+ * @return {null} The event referred to an unknown megolm session
+ * @return {module:crypto.DecryptionResult} decryption result
  *
  * @throws {module:crypto/algorithms/base.DecryptionError} if there is a
  *   problem decrypting the event
@@ -364,9 +407,6 @@ utils.inherits(MegolmDecryption, base.DecryptionAlgorithm);
 MegolmDecryption.prototype.decryptEvent = function(event) {
     var content = event.content;
 
-    console.log("decrypting " + event.event_id + " with sid " +
-                content.session_id);
-
     if (!content.sender_key || !content.session_id ||
         !content.ciphertext
        ) {
@@ -377,7 +417,14 @@ MegolmDecryption.prototype.decryptEvent = function(event) {
         var res = this._olmDevice.decryptGroupMessage(
             event.room_id, content.sender_key, content.session_id, content.ciphertext
         );
-        return JSON.parse(res);
+        if (res === null) {
+            return null;
+        }
+        return {
+            payload: JSON.parse(res.result),
+            keysClaimed: res.keysClaimed,
+            keysProved: res.keysProved,
+        };
     } catch (e) {
         throw new base.DecryptionError(e);
     }
@@ -394,8 +441,7 @@ MegolmDecryption.prototype.onRoomKeyEvent = function(event) {
 
     if (!content.room_id ||
         !content.session_id ||
-        !content.session_key ||
-        content.chain_index === undefined
+        !content.session_key
        ) {
         console.error("key event is missing fields");
         return;
@@ -403,7 +449,7 @@ MegolmDecryption.prototype.onRoomKeyEvent = function(event) {
 
     this._olmDevice.addInboundGroupSession(
         content.room_id, event.getSenderKey(), content.session_id,
-        content.session_key, content.chain_index
+        content.session_key, event.getKeysClaimed()
     );
 };
 

lib/crypto/algorithms/olm.js

@@ -142,7 +142,7 @@ utils.inherits(OlmDecryption, base.DecryptionAlgorithm);
  *
  * @param {object} event raw event
  *
- * @return {object} decrypted payload (with properties 'type', 'content')
+ * @return {module:crypto.DecryptionResult} decryption result
  *
  * @throws {module:crypto/algorithms/base.DecryptionError} if there is a
  *   problem decrypting the event
@@ -156,52 +156,116 @@ OlmDecryption.prototype.decryptEvent = function(event) {
         throw new base.DecryptionError("Missing ciphertext");
     }
 
-    if (!(this._olmDevice.deviceCurve25519Key in content.ciphertext)) {
+    if (!(this._olmDevice.deviceCurve25519Key in ciphertext)) {
         throw new base.DecryptionError("Not included in recipients");
     }
+    var message = ciphertext[this._olmDevice.deviceCurve25519Key];
+    var payloadString;
 
-    var message = content.ciphertext[this._olmDevice.deviceCurve25519Key];
-    var sessionIds = this._olmDevice.getSessionIdsForDevice(deviceKey);
-    var payloadString = null;
-    var foundSession = false;
-    for (var i = 0; i < sessionIds.length; i++) {
-        var sessionId = sessionIds[i];
-        var res = this._olmDevice.decryptMessage(
-            deviceKey, sessionId, message.type, message.body
+    try {
+        payloadString = this._decryptMessage(deviceKey, message);
+    } catch (e) {
+        console.warn(
+            "Failed to decrypt Olm event (id=" +
+                event.event_id + ") from " + deviceKey +
+                ": " + e.message
         );
-        payloadString = res.payload;
-        if (payloadString) {
-            console.log("decrypted with sessionId " + sessionId);
-            break;
-        }
-
-        if (res.matchesInbound) {
-            // this was a prekey message which matched this session; don't
-            // create a new session.
-            foundSession = true;
-            break;
-        }
+        throw new base.DecryptionError("Bad Encrypted Message");
     }
 
-    if (message.type === 0 && !foundSession && payloadString === null) {
-        try {
-            payloadString = this._olmDevice.createInboundSession(
-                deviceKey, message.type, message.body
-            );
-            console.log("created new inbound sesion");
-        } catch (e) {
-            // Failed to decrypt with a new session.
-            console.warn("Failed to decrypt message with new session", e);
-        }
-    }
 
     // TODO: Check the sender user id matches the sender key.
     // TODO: check the room_id and fingerprint
-    if (payloadString !== null) {
-        return JSON.parse(payloadString);
-    } else {
-        throw new base.DecryptionError("Bad Encrypted Message");
-    }
+    var payload = JSON.parse(payloadString);
+    return {
+        payload: payload,
+        sessionExists: true,
+        keysProved: {curve25519: deviceKey},
+        keysClaimed: payload.keys || {}
+    };
 };
 
+
+/**
+ * Attempt to decrypt an Olm message
+ *
+ * @param {string} theirDeviceIdentityKey  Curve25519 identity key of the sender
+ * @param {object} message  message object, with 'type' and 'body' fields
+ *
+ * @return {string} payload, if decrypted successfully.
+ */
+OlmDecryption.prototype._decryptMessage = function(theirDeviceIdentityKey, message) {
+    var sessionIds = this._olmDevice.getSessionIdsForDevice(theirDeviceIdentityKey);
+
+    // try each session in turn.
+    var decryptionErrors = {};
+    for (var i = 0; i < sessionIds.length; i++) {
+        var sessionId = sessionIds[i];
+        try {
+            var payload = this._olmDevice.decryptMessage(
+                theirDeviceIdentityKey, sessionId, message.type, message.body
+            );
+            console.log(
+                "Decrypted Olm message from " + theirDeviceIdentityKey +
+                    " with session " + sessionId
+            );
+            return payload;
+        } catch (e) {
+            var foundSession = this._olmDevice.matchesSession(
+                theirDeviceIdentityKey, sessionId, message.type, message.body
+            );
+
+            if (foundSession) {
+                // decryption failed, but it was a prekey message matching this
+                // session, so it should have worked.
+                throw new Error(
+                    "Error decrypting prekey message with existing session id " +
+                        sessionId + ": " + e.message
+                );
+            }
+
+            // otherwise it's probably a message for another session; carry on, but
+            // keep a record of the error
+            decryptionErrors[sessionId] = e.message;
+        }
+    }
+
+    if (message.type !== 0) {
+        // not a prekey message, so it should have matched an existing session, but it
+        // didn't work.
+
+        if (sessionIds.length === 0) {
+            throw new Error("No existing sessions");
+        }
+
+        throw new Error(
+            "Error decrypting non-prekey message with existing sessions: " +
+                JSON.stringify(decryptionErrors)
+        );
+    }
+
+    // prekey message which doesn't match any existing sessions: make a new
+    // session.
+
+    var res;
+    try {
+        res = this._olmDevice.createInboundSession(
+            theirDeviceIdentityKey, message.type, message.body
+        );
+    } catch (e) {
+        decryptionErrors["(new)"] = e.message;
+        throw new Error(
+            "Error decrypting prekey message: " +
+                JSON.stringify(decryptionErrors)
+        );
+    }
+
+    console.log(
+        "created new inbound Olm session ID " +
+            res.session_id + " with " + theirDeviceIdentityKey
+    );
+    return res.payload;
+};
+
+
 base.registerAlgorithm(olmlib.OLM_ALGORITHM, OlmEncryption, OlmDecryption);

lib/crypto/index.js

@@ -85,6 +85,9 @@ function Crypto(baseApis, eventEmitter, sessionStore, userId, deviceId) {
     );
 
     _registerEventHandlers(this, eventEmitter);
+
+    // map from userId -> deviceId -> roomId -> timestamp
+    this._lastNewDeviceMessageTsByUserDeviceRoom = {};
 }
 
 function _registerEventHandlers(crypto, eventEmitter) {
@@ -133,6 +136,13 @@ function _registerEventHandlers(crypto, eventEmitter) {
     });
 }
 
+/**
+ * @return {string} The version of Olm.
+ */
+Crypto.getOlmVersion = function() {
+    return OlmDevice.getOlmVersion();
+};
+
 /**
  * Get the Ed25519 key for this device
  *
@@ -151,18 +161,46 @@ Crypto.prototype.getDeviceEd25519Key = function() {
 Crypto.prototype.uploadKeys = function(maxKeys) {
     var self = this;
     return _uploadDeviceKeys(this).then(function(res) {
+        // We need to keep a pool of one time public keys on the server so that
+        // other devices can start conversations with us. But we can only store
+        // a finite number of private keys in the olm Account object.
+        // To complicate things further then can be a delay between a device
+        // claiming a public one time key from the server and it sending us a
+        // message. We need to keep the corresponding private key locally until
+        // we receive the message.
+        // But that message might never arrive leaving us stuck with duff
+        // private keys clogging up our local storage.
+        // So we need some kind of enginering compromise to balance all of
+        // these factors.
+
+        // We first find how many keys the server has for us.
         var keyCount = res.one_time_key_counts.curve25519 || 0;
+        // We then check how many keys we can store in the Account object.
         var maxOneTimeKeys = self._olmDevice.maxNumberOfOneTimeKeys();
+        // Try to keep at most half that number on the server. This leaves the
+        // rest of the slots free to hold keys that have been claimed from the
+        // server but we haven't recevied a message for.
+        // If we run out of slots when generating new keys then olm will
+        // discard the oldest private keys first. This will eventually clean
+        // out stale private keys that won't receive a message.
         var keyLimit = Math.floor(maxOneTimeKeys / 2);
+        // We work out how many new keys we need to create to top up the server
+        // If there are too many keys on the server then we don't need to
+        // create any more keys.
         var numberToGenerate = Math.max(keyLimit - keyCount, 0);
         if (maxKeys !== undefined) {
+            // Creating keys can be an expensive operation so we limit the
+            // number we generate in one go to avoid blocking the application
+            // for too long.
             numberToGenerate = Math.min(numberToGenerate, maxKeys);
         }
 
         if (numberToGenerate <= 0) {
+            // If we don't need to generate any keys then we are done.
             return;
         }
 
+        // Ask olm to generate new one time keys, then upload them to synapse.
         self._olmDevice.generateOneTimeKeys(numberToGenerate);
         return _uploadOneTimeKeys(self);
     });
@@ -280,10 +318,10 @@ Crypto.prototype.downloadKeys = function(userIds, forceDownload) {
                 }
 
                 storage[deviceId] = userStore[deviceId].toStorage();
-                self._sessionStore.storeEndToEndDevicesForUser(
-                    userId, storage
-                );
             }
+            self._sessionStore.storeEndToEndDevicesForUser(
+                userId, storage
+            );
         }
         return stored;
     });
@@ -573,33 +611,56 @@ Crypto.prototype.getOlmSessionsForUser = function(userId) {
 
 
 /**
- * Identify a device by curve25519 identity key and determine its verification state
+ * Get the device which sent an event
  *
- * @param {string} userId     owner of the device
- * @param {string} algorithm  encryption algorithm
- * @param {string} sender_key curve25519 key to match
+ * @param {module:models/event.MatrixEvent} event event to be checked
  *
- * @return {boolean} true if the device is verified
+ * @return {module:crypto/deviceinfo?}
  */
-Crypto.prototype.isSenderKeyVerified = function(userId, algorithm, sender_key) {
+Crypto.prototype.getEventSenderDeviceInfo = function(event) {
+    var sender_key = event.getSenderKey();
+    var algorithm = event.getWireContent().algorithm;
 
-    // sender_key is the curve25519 public key of the device, that the event
-    // purports to have been sent from. It's assumed that, by the time we get here,
-    // we have already checked that the event was, in fact, sent by that device.
-    //
-    // In the case of both olm and megolm, that is achieved primarily by the
-    // fact that sessions are indexed by the curve25519 key of the device that
-    // created the session, and we assume that only that device has the keys
-    // necessary to create valid messages in that session.
-    //
-    // So, all we need to do here is look up the device by sender and
-    // curve25519 key and determine the state of the verification flag.
-
-    var device = this.getDeviceByIdentityKey(userId, algorithm, sender_key);
-    if (!device) {
-        return false;
+    if (!sender_key || !algorithm) {
+        return null;
     }
-    return device.verified == DeviceVerification.VERIFIED;
+
+    // sender_key is the Curve25519 identity key of the device which the event
+    // was sent from. In the case of Megolm, it's actually the Curve25519
+    // identity key of the device which set up the Megolm session.
+
+    var device = this.getDeviceByIdentityKey(
+        event.getSender(), algorithm, sender_key
+    );
+
+    if (device === null) {
+        // we haven't downloaded the details of this device yet.
+        return null;
+    }
+
+    // so far so good, but now we need to check that the sender of this event
+    // hadn't advertised someone else's Curve25519 key as their own. We do that
+    // by checking the Ed25519 claimed by the event (or, in the case of megolm,
+    // the event which set up the megolm session), to check that it matches the
+    // fingerprint of the purported sending device.
+    //
+    // (see https://github.com/vector-im/vector-web/issues/2215)
+
+    var claimedKey = event.getKeysClaimed().ed25519;
+    if (!claimedKey) {
+        console.warn("Event " + event.getId() + " claims no ed25519 key: " +
+                     "cannot verify sending device");
+        return null;
+    }
+
+    if (claimedKey !== device.getFingerprint()) {
+        console.warn(
+            "Event " + event.getId() + " claims ed25519 key " + claimedKey +
+                "but sender device has key " + device.getFingerprint());
+        return null;
+    }
+
+    return device;
 };
 
 
@@ -717,7 +778,7 @@ Crypto.prototype.ensureOlmSessionsForUsers = function(users) {
 
             var userRes = res.one_time_keys[userId] || {};
             var deviceRes = userRes[deviceId];
-            var oneTimeKey;
+            var oneTimeKey = null;
             for (var keyId in deviceRes) {
                 if (keyId.indexOf("curve25519:") === 0) {
                     oneTimeKey = deviceRes[keyId];
@@ -795,19 +856,41 @@ Crypto.prototype.encryptEventIfNeeded = function(event, room) {
         return null;
     }
 
+    // We can claim and prove ownership of all our device keys in the local
+    // echo of the event since we know that all the local echos come from
+    // this device.
+    var myKeys = {
+        curve25519: this._olmDevice.deviceCurve25519Key,
+        ed25519: this._olmDevice.deviceEd25519Key,
+    };
+
     return alg.encryptMessage(
         room, event.getType(), event.getContent()
     ).then(function(encryptedContent) {
-        event.makeEncrypted("m.room.encrypted", encryptedContent);
+        event.makeEncrypted("m.room.encrypted", encryptedContent, myKeys);
     });
 };
 
+/**
+ * @typedef {Object} module:crypto.DecryptionResult
+ *
+ * @property {Object} payload decrypted payload (with properties 'type',
+ *     'content').
+ *
+ * @property {Object<string, string>} keysClaimed keys that the sender of the
+ *     event claims ownership of: map from key type to base64-encoded key
+ *
+ * @property {Object<string, string>} keysProved keys that the sender of the
+ *     event is known to have ownership of: map from key type to base64-encoded
+ *     key
+ */
+
 /**
  * Decrypt a received event
  *
  * @param {object} event raw event
  *
- * @return {object} decrypted payload (with properties 'type', 'content')
+ * @return {module:crypto.DecryptionResult} decryption result
  *
  * @raises {algorithms.DecryptionError} if there is a problem decrypting the event
  */
@@ -820,7 +903,85 @@ Crypto.prototype.decryptEvent = function(event) {
     var alg = new AlgClass({
         olmDevice: this._olmDevice,
     });
-    return alg.decryptEvent(event);
+    var r = alg.decryptEvent(event);
+
+    if (r !== null) {
+        return r;
+    } else {
+        // We've got a message for a session we don't have.  Maybe the sender
+        // forgot to tell us about the session.  Remind the sender that we
+        // exist so that they might tell us about the session on their next
+        // send.
+        //
+        // (Alternatively, it might be that we are just looking at
+        // scrollback... at least we rate-limit the m.new_device events :/)
+        //
+        // XXX: this is a band-aid which masks symptoms of other bugs. It would
+        // be nice to get rid of it.
+        if (event.room_id !== undefined && event.sender !== undefined) {
+            var device_id = event.content.device_id;
+            if (device_id === undefined) {
+                // if the sending device didn't tell us its device_id, fall
+                // back to all devices.
+                device_id = null;
+            }
+            this._sendPingToDevice(event.sender, device_id, event.room_id);
+        }
+
+        throw new algorithms.DecryptionError("Unknown inbound session id");
+    }
+};
+
+/**
+ * Send a "m.new_device" message to remind it that we exist and are a member
+ * of a room.
+ *
+ * This is rate limited to send a message at most once an hour per desination.
+ *
+ * @param {string}  userId   The ID of the user to ping.
+ * @param {string?} deviceId The ID of the device to ping. If null, all
+ *     devices.
+ * @param {string}  roomId   The ID of the room we want to remind them about.
+ */
+Crypto.prototype._sendPingToDevice = function(userId, deviceId, roomId) {
+    if (deviceId === null) {
+        deviceId = "*";
+    }
+
+    var lastMessageTsMap = this._lastNewDeviceMessageTsByUserDeviceRoom;
+
+    var lastTsByDevice = lastMessageTsMap[userId];
+    if (!lastTsByDevice) {
+        lastTsByDevice = lastMessageTsMap[userId] = {};
+    }
+
+    var lastTsByRoom = lastTsByDevice[deviceId];
+    if (!lastTsByRoom) {
+        lastTsByRoom = lastTsByDevice[deviceId] = {};
+    }
+
+    var lastTs = lastTsByRoom[roomId];
+    var timeNowMs = Date.now();
+    var oneHourMs = 1000 * 60 * 60;
+
+    if (lastTs !== undefined && lastTs + oneHourMs > timeNowMs) {
+        // rate-limiting
+        return;
+    }
+
+    var content = {};
+    content[userId] = {};
+    content[userId][deviceId] = {
+        device_id: this._deviceId,
+        rooms: [roomId],
+    };
+
+    this._baseApis.sendToDevice(
+        "m.new_device", // OH HAI!
+        content
+    ).done();
+
+    lastTsByRoom[roomId] = timeNowMs;
 };
 
 /**
@@ -938,9 +1099,10 @@ Crypto.prototype._onRoomKeyEvent = function(event) {
  */
 Crypto.prototype._onRoomMembership = function(event, member, oldMembership) {
 
-    // this event handler is registered on the *client* (as opposed to the
-    // room member itself), which means it is only called on changes to the
-    // *live* membership state (ie, it is not called when we back-paginate).
+    // this event handler is registered on the *client* (as opposed to the room
+    // member itself), which means it is only called on changes to the *live*
+    // membership state (ie, it is not called when we back-paginate, nor when
+    // we load the state in the initialsync).
     //
     // Further, it is automatically registered and called when new members
     // arrive in the room.
@@ -974,6 +1136,9 @@ Crypto.prototype._onNewDeviceEvent = function(event) {
         return;
     }
 
+    console.log("m.new_device event from " + userId + ":" + deviceId +
+                " for rooms " + rooms);
+
     var self = this;
     this.downloadKeys(
         [userId], true

lib/crypto/olmlib.js

@@ -51,6 +51,18 @@ module.exports.encryptMessageForDevices = function(
     var payloadJson = {
         fingerprint: participantHash,
         sender_device: ourDeviceId,
+
+        // Include the Ed25519 key so that the recipient knows what
+        // device this message came from.
+        // We don't need to include the curve25519 key since the
+        // recipient will already know this from the olm headers.
+        // When combined with the device keys retrieved from the
+        // homeserver signed by the ed25519 key this proves that
+        // the curve25519 key and the ed25519 key are owned by
+        // the same device.
+        keys: {
+            "ed25519": olmDevice.deviceEd25519Key,
+        },
     };
     utils.extend(payloadJson, payloadFields);
 

lib/http-api.js

@@ -63,9 +63,11 @@ module.exports.PREFIX_MEDIA_R0 = "/_matrix/media/r0";
  * requests. This function must look like function(opts, callback){ ... }.
  * @param {string} opts.prefix Required. The matrix client prefix to use, e.g.
  * '/_matrix/client/r0'. See PREFIX_R0 and PREFIX_UNSTABLE for constants.
- * @param {bool} opts.onlyData True to return only the 'data' component of the
- * response (e.g. the parsed HTTP body). If false, requests will return status
- * codes and headers in addition to data. Default: false.
+ *
+ * @param {bool=} opts.onlyData True to return only the 'data' component of the
+ * response (e.g. the parsed HTTP body). If false, requests will return an
+ * object with the properties <tt>code</tt>, <tt>headers</tt> and <tt>data</tt>.
+ *
  * @param {string} opts.accessToken The access_token to send with requests. Can be
  * null to not send an access token.
  * @param {Object} opts.extraParams Optional. Extra query parameters to send on
@@ -99,22 +101,87 @@ module.exports.MatrixHttpApi.prototype = {
 
     /**
      * Upload content to the Home Server
-     * @param {File} file A File object (in a browser) or in Node,
-                                 an object with properties:
-                                 name: The file's name
-                                 stream: A read stream
-     * @param {Function} callback Optional. The callback to invoke on
-     * success/failure. See the promise return values for more information.
-     * @return {module:client.Promise} Resolves to <code>{data: {Object},
+     *
+     * @param {object} file The object to upload. On a browser, something that
+     *   can be sent to XMLHttpRequest.send (typically a File).  Under node.js,
+     *   a a Buffer, String or ReadStream.
+     *
+     * @param {object} opts  options object
+     *
+     * @param {string=} opts.name   Name to give the file on the server. Defaults
+     *   to <tt>file.name</tt>.
+     *
+     * @param {string=} opts.type   Content-type for the upload. Defaults to
+     *   <tt>file.type</tt>, or <tt>applicaton/octet-stream</tt>.
+     *
+     * @param {boolean=} opts.rawResponse Return the raw body, rather than
+     *   parsing the JSON. Defaults to false (except on node.js, where it
+     *   defaults to true for backwards compatibility).
+     *
+     * @param {boolean=} opts.onlyContentUri Just return the content URI,
+     *   rather than the whole body. Defaults to false (except on browsers,
+     *   where it defaults to true for backwards compatibility). Ignored if
+     *   opts.rawResponse is true.
+     *
+     * @param {Function=} opts.callback Deprecated. Optional. The callback to
+     *    invoke on success/failure. See the promise return values for more
+     *    information.
+     *
+     * @return {module:client.Promise} Resolves to response object, as
+     *    determined by this.opts.onlyData, opts.rawResponse, and
+     *    opts.onlyContentUri.  Rejects with an error (usually a MatrixError).
      */
-    uploadContent: function(file, callback) {
-        if (callback !== undefined && !utils.isFunction(callback)) {
-            throw Error(
-                "Expected callback to be a function but got " + typeof callback
-            );
+    uploadContent: function(file, opts) {
+        if (utils.isFunction(opts)) {
+            // opts used to be callback
+            opts = {
+                callback: opts,
+            };
+        } else if (opts === undefined) {
+            opts = {};
         }
-        var defer = q.defer();
-        var url = this.opts.baseUrl + "/_matrix/media/v1/upload";
+
+        // if the file doesn't have a mime type, use a default since
+        // the HS errors if we don't supply one.
+        var contentType = opts.type || file.type || 'application/octet-stream';
+        var fileName = opts.name || file.name;
+
+        // we used to recommend setting file.stream to the thing to upload on
+        // nodejs.
+        var body = file.stream ? file.stream : file;
+
+        // backwards-compatibility hacks where we used to do different things
+        // between browser and node.
+        var rawResponse = opts.rawResponse;
+        if (rawResponse === undefined) {
+            if (global.XMLHttpRequest) {
+                rawResponse = false;
+            } else {
+                console.warn(
+                    "Returning the raw JSON from uploadContent(). Future " +
+                    "versions of the js-sdk will change this default, to " +
+                    "return the parsed object. Set opts.rawResponse=false " +
+                    "to change this behaviour now."
+                );
+                rawResponse = true;
+            }
+        }
+
+        var onlyContentUri = opts.onlyContentUri;
+        if (!rawResponse && onlyContentUri === undefined) {
+            if (global.XMLHttpRequest) {
+                console.warn(
+                    "Returning only the content-uri from uploadContent(). " +
+                    "Future versions of the js-sdk will change this " +
+                    "default, to return the whole response object. Set " +
+                    "opts.onlyContentUri=false to change this behaviour now."
+                );
+                onlyContentUri = true;
+            } else {
+                onlyContentUri = false;
+            }
+        }
+
         // browser-request doesn't support File objects because it deep-copies
         // the options using JSON.parse(JSON.stringify(options)). Instead of
         // loading the whole file into memory as a string and letting
@@ -124,40 +191,60 @@ module.exports.MatrixHttpApi.prototype = {
         // of important here)
 
         var upload = { loaded: 0, total: 0 };
+        var promise;
+
+        // XMLHttpRequest doesn't parse JSON for us. request normally does, but
+        // we're setting opts.json=false so that it doesn't JSON-encode the
+        // request, which also means it doesn't JSON-decode the response. Either
+        // way, we have to JSON-parse the response ourselves.
+        var bodyParser = null;
+        if (!rawResponse) {
+            bodyParser = function(rawBody) {
+                var body = JSON.parse(rawBody);
+                if (onlyContentUri) {
+                    body = body.content_uri;
+                    if (body === undefined) {
+                        throw Error('Bad response');
+                    }
+                }
+                return body;
+            };
+        }
 
         if (global.XMLHttpRequest) {
+            var defer = q.defer();
             var xhr = new global.XMLHttpRequest();
             upload.xhr = xhr;
-            var cb = requestCallback(defer, callback, this.opts.onlyData);
+            var cb = requestCallback(defer, opts.callback, this.opts.onlyData);
 
             var timeout_fn = function() {
                 xhr.abort();
                 cb(new Error('Timeout'));
             };
 
+            // set an initial timeout of 30s; we'll advance it each time we get
+            // a progress notification
             xhr.timeout_timer = callbacks.setTimeout(timeout_fn, 30000);
 
             xhr.onreadystatechange = function() {
                 switch (xhr.readyState) {
                     case global.XMLHttpRequest.DONE:
                         callbacks.clearTimeout(xhr.timeout_timer);
-                        var err;
-                        if (!xhr.responseText) {
-                            err = new Error('No response body.');
+                        var resp;
+                        try {
+                            if (!xhr.responseText) {
+                                throw new Error('No response body.');
+                            }
+                            resp = xhr.responseText;
+                            if (bodyParser) {
+                                resp = bodyParser(resp);
+                            }
+                        } catch (err) {
                             err.http_status = xhr.status;
                             cb(err);
                             return;
                         }
-
-                        var resp = JSON.parse(xhr.responseText);
-                        if (resp.content_uri === undefined) {
-                            err = Error('Bad response');
-                            err.http_status = xhr.status;
-                            cb(err);
-                            return;
-                        }
-
-                        cb(undefined, xhr, resp.content_uri);
+                        cb(undefined, xhr, resp);
                         break;
                 }
             };
@@ -168,59 +255,57 @@ module.exports.MatrixHttpApi.prototype = {
                 xhr.timeout_timer = callbacks.setTimeout(timeout_fn, 30000);
                 defer.notify(ev);
             });
+            var url = this.opts.baseUrl + "/_matrix/media/v1/upload";
             url += "?access_token=" + encodeURIComponent(this.opts.accessToken);
-            url += "&filename=" + encodeURIComponent(file.name);
+            url += "&filename=" + encodeURIComponent(fileName);
 
             xhr.open("POST", url);
-            if (file.type) {
-                xhr.setRequestHeader("Content-Type", file.type);
-            } else {
-                // if the file doesn't have a mime type, use a default since
-                // the HS errors if we don't supply one.
-                xhr.setRequestHeader("Content-Type", 'application/octet-stream');
-            }
-            xhr.send(file);
+            xhr.setRequestHeader("Content-Type", contentType);
+            xhr.send(body);
+            promise = defer.promise;
+
+            // dirty hack (as per _request) to allow the upload to be cancelled.
+            promise.abort = xhr.abort.bind(xhr);
         } else {
             var queryParams = {
-                filename: file.name,
-                access_token: this.opts.accessToken
+                filename: fileName,
             };
-            upload.request = this.opts.request({
-                uri: url,
-                qs: queryParams,
-                method: "POST",
-                headers: {"Content-Type": file.type},
-                body: file.stream
-            }, requestCallback(defer, callback, this.opts.onlyData));
+
+            promise = this.authedRequest(
+                opts.callback, "POST", "/upload", queryParams, body, {
+                    prefix: "/_matrix/media/v1",
+                    headers: {"Content-Type": contentType},
+                    json: false,
+                    bodyParser: bodyParser,
+                }
+            );
         }
 
-        this.uploads.push(upload);
-
         var self = this;
-        upload.promise = defer.promise.finally(function() {
-            var uploadsKeys = Object.keys(self.uploads);
-            for (var i = 0; i < uploadsKeys.length; ++i) {
-                if (self.uploads[uploadsKeys[i]].promise === defer.promise) {
-                    self.uploads.splice(uploadsKeys[i], 1);
+
+        // remove the upload from the list on completion
+        var promise0 = promise.finally(function() {
+            for (var i = 0; i < self.uploads.length; ++i) {
+                if (self.uploads[i] === upload) {
+                    self.uploads.splice(i, 1);
+                    return;
                 }
             }
         });
-        return upload.promise;
+
+        // copy our dirty abort() method to the new promise
+        promise0.abort = promise.abort;
+
+        upload.promise = promise0;
+        this.uploads.push(upload);
+
+        return promise0;
     },
 
     cancelUpload: function(promise) {
-        var uploadsKeys = Object.keys(this.uploads);
-        for (var i = 0; i < uploadsKeys.length; ++i) {
-            var upload = this.uploads[uploadsKeys[i]];
-            if (upload.promise === promise) {
-                if (upload.xhr !== undefined) {
-                    upload.xhr.abort();
-                    return true;
-                } else if (upload.request !== undefined) {
-                    upload.request.abort();
-                    return true;
-                }
-            }
+        if (promise.abort) {
+            promise.abort();
+            return true;
         }
         return false;
     },
@@ -271,11 +356,22 @@ module.exports.MatrixHttpApi.prototype = {
      * @param {string} method The HTTP method e.g. "GET".
      * @param {string} path The HTTP path <b>after</b> the supplied prefix e.g.
      * "/createRoom".
-     * @param {Object} queryParams A dict of query params (these will NOT be
-     * urlencoded).
+     *
+     * @param {Object=} queryParams A dict of query params (these will NOT be
+     * urlencoded). If unspecified, there will be no query params.
+     *
      * @param {Object} data The HTTP JSON body.
-     * @param {Number=} localTimeoutMs The maximum amount of time to wait before
+     *
+     * @param {Object=} opts additional options
+     *
+     * @param {Number=} opts.localTimeoutMs The maximum amount of time to wait before
      * timing out the request. If not specified, there is no timeout.
+     *
+     * @param {sting=} opts.prefix The full prefix to use e.g.
+     * "/_matrix/client/v2_alpha". If not specified, uses this.opts.prefix.
+     *
+     * @param {Object=} opts.headers map of additional request headers
+     *
      * @return {module:client.Promise} Resolves to <code>{data: {Object},
      * headers: {Object}, code: {Number}}</code>.
      * If <code>onlyData</code> is set, this will resolve to the <code>data</code>
@@ -283,18 +379,25 @@ module.exports.MatrixHttpApi.prototype = {
      * @return {module:http-api.MatrixError} Rejects with an error if a problem
      * occurred. This includes network problems and Matrix-specific error JSON.
      */
-    authedRequest: function(callback, method, path, queryParams, data, localTimeoutMs) {
-        if (!queryParams) { queryParams = {}; }
-        queryParams.access_token = this.opts.accessToken;
-        var self = this;
+    authedRequest: function(callback, method, path, queryParams, data, opts) {
+        if (!queryParams) {
+            queryParams = {};
+        }
+        if (!queryParams.access_token) {
+            queryParams.access_token = this.opts.accessToken;
+        }
+
         var request_promise = this.request(
-            callback, method, path, queryParams, data, localTimeoutMs
+            callback, method, path, queryParams, data, opts
         );
+
+        var self = this;
         request_promise.catch(function(err) {
             if (err.errcode == 'M_UNKNOWN_TOKEN') {
                 self.event_emitter.emit("Session.logged_out");
             }
         });
+
         // return the original promise, otherwise tests break due to it having to
         // go around the event loop one more time to process the result of the request
         return request_promise;
@@ -307,11 +410,22 @@ module.exports.MatrixHttpApi.prototype = {
      * @param {string} method The HTTP method e.g. "GET".
      * @param {string} path The HTTP path <b>after</b> the supplied prefix e.g.
      * "/createRoom".
-     * @param {Object} queryParams A dict of query params (these will NOT be
-     * urlencoded).
+     *
+     * @param {Object=} queryParams A dict of query params (these will NOT be
+     * urlencoded). If unspecified, there will be no query params.
+     *
      * @param {Object} data The HTTP JSON body.
-     * @param {Number=} localTimeoutMs The maximum amount of time to wait before
+     *
+     * @param {Object=} opts additional options
+     *
+     * @param {Number=} opts.localTimeoutMs The maximum amount of time to wait before
      * timing out the request. If not specified, there is no timeout.
+     *
+     * @param {sting=} opts.prefix The full prefix to use e.g.
+     * "/_matrix/client/v2_alpha". If not specified, uses this.opts.prefix.
+     *
+     * @param {Object=} opts.headers map of additional request headers
+     *
      * @return {module:client.Promise} Resolves to <code>{data: {Object},
      * headers: {Object}, code: {Number}}</code>.
      * If <code>onlyData</code> is set, this will resolve to the <code>data</code>
@@ -319,9 +433,13 @@ module.exports.MatrixHttpApi.prototype = {
      * @return {module:http-api.MatrixError} Rejects with an error if a problem
      * occurred. This includes network problems and Matrix-specific error JSON.
      */
-    request: function(callback, method, path, queryParams, data, localTimeoutMs) {
-        return this.requestWithPrefix(
-            callback, method, path, queryParams, data, this.opts.prefix, localTimeoutMs
+    request: function(callback, method, path, queryParams, data, opts) {
+        opts = opts || {};
+        var prefix = opts.prefix !== undefined ? opts.prefix : this.opts.prefix;
+        var fullUri = this.opts.baseUrl + prefix + path;
+
+        return this.requestOtherUrl(
+            callback, method, fullUri, queryParams, data, opts
         );
     },
 
@@ -347,16 +465,16 @@ module.exports.MatrixHttpApi.prototype = {
      * object only.
      * @return {module:http-api.MatrixError} Rejects with an error if a problem
      * occurred. This includes network problems and Matrix-specific error JSON.
+     *
+     * @deprecated prefer authedRequest with opts.prefix
      */
     authedRequestWithPrefix: function(callback, method, path, queryParams, data,
                                       prefix, localTimeoutMs) {
-        var fullUri = this.opts.baseUrl + prefix + path;
-        if (!queryParams) {
-            queryParams = {};
-        }
-        queryParams.access_token = this.opts.accessToken;
-        return this._request(
-            callback, method, fullUri, queryParams, data, localTimeoutMs
+        return this.authedRequest(
+            callback, method, path, queryParams, data, {
+                localTimeoutMs: localTimeoutMs,
+                prefix: prefix,
+            }
         );
     },
 
@@ -382,15 +500,16 @@ module.exports.MatrixHttpApi.prototype = {
      * object only.
      * @return {module:http-api.MatrixError} Rejects with an error if a problem
      * occurred. This includes network problems and Matrix-specific error JSON.
+     *
+     * @deprecated prefer request with opts.prefix
      */
     requestWithPrefix: function(callback, method, path, queryParams, data, prefix,
                                 localTimeoutMs) {
-        var fullUri = this.opts.baseUrl + prefix + path;
-        if (!queryParams) {
-            queryParams = {};
-        }
-        return this._request(
-            callback, method, fullUri, queryParams, data, localTimeoutMs
+        return this.request(
+            callback, method, path, queryParams, data, {
+                localTimeoutMs: localTimeoutMs,
+                prefix: prefix,
+            }
         );
     },
 
@@ -400,11 +519,22 @@ module.exports.MatrixHttpApi.prototype = {
      * success/failure. See the promise return values for more information.
      * @param {string} method The HTTP method e.g. "GET".
      * @param {string} uri The HTTP URI
-     * @param {Object} queryParams A dict of query params (these will NOT be
-     * urlencoded).
+     *
+     * @param {Object=} queryParams A dict of query params (these will NOT be
+     * urlencoded). If unspecified, there will be no query params.
+     *
      * @param {Object} data The HTTP JSON body.
-     * @param {Number=} localTimeoutMs The maximum amount of time to wait before
+     *
+     * @param {Object=} opts additional options
+     *
+     * @param {Number=} opts.localTimeoutMs The maximum amount of time to wait before
      * timing out the request. If not specified, there is no timeout.
+     *
+     * @param {sting=} opts.prefix The full prefix to use e.g.
+     * "/_matrix/client/v2_alpha". If not specified, uses this.opts.prefix.
+     *
+     * @param {Object=} opts.headers map of additional request headers
+     *
      * @return {module:client.Promise} Resolves to <code>{data: {Object},
      * headers: {Object}, code: {Number}}</code>.
      * If <code>onlyData</code> is set, this will resolve to the <code>data</code>
@@ -413,12 +543,18 @@ module.exports.MatrixHttpApi.prototype = {
      * occurred. This includes network problems and Matrix-specific error JSON.
      */
     requestOtherUrl: function(callback, method, uri, queryParams, data,
-                                localTimeoutMs) {
-        if (!queryParams) {
-            queryParams = {};
+                              opts) {
+        if (opts === undefined || opts === null) {
+            opts = {};
+        } else if (isFinite(opts)) {
+            // opts used to be localTimeoutMs
+            opts = {
+                localTimeoutMs: opts
+            };
         }
+
         return this._request(
-            callback, method, uri, queryParams, data, localTimeoutMs
+            callback, method, uri, queryParams, data, opts
         );
     },
 
@@ -441,27 +577,56 @@ module.exports.MatrixHttpApi.prototype = {
         return this.opts.baseUrl + prefix + path + queryString;
     },
 
-    _request: function(callback, method, uri, queryParams, data, localTimeoutMs) {
+    /**
+     * @private
+     *
+     * @param {function} callback
+     * @param {string} method
+     * @param {string} uri
+     * @param {object} queryParams
+     * @param {object|string} data
+     * @param {object=} opts
+     *
+     * @param {boolean=true} opts.json Json-encode data before sending, and
+     *   decode response on receipt. (We will still json-decode error
+     *   responses, even if this is false.)
+     *
+     * @param {object=} opts.headers  extra request headers
+     *
+     * @param {number=} opts.localTimeoutMs client-side timeout for the
+     *    request. No timeout if undefined.
+     *
+     * @param {function=} opts.bodyParser function to parse the body of the
+     *    response before passing it to the promise and callback.
+     *
+     * @return {module:client.Promise} a promise which resolves to either the
+     * response object (if this.opts.onlyData is truthy), or the parsed
+     * body. Rejects
+     */
+    _request: function(callback, method, uri, queryParams, data, opts) {
         if (callback !== undefined && !utils.isFunction(callback)) {
             throw Error(
                 "Expected callback to be a function but got " + typeof callback
             );
         }
+        opts = opts || {};
+
         var self = this;
-        if (!queryParams) {
-            queryParams = {};
-        }
         if (this.opts.extraParams) {
             for (var key in this.opts.extraParams) {
                 if (!this.opts.extraParams.hasOwnProperty(key)) { continue; }
                 queryParams[key] = this.opts.extraParams[key];
             }
         }
+
+        var json = opts.json === undefined ? true : opts.json;
+
         var defer = q.defer();
 
         var timeoutId;
         var timedOut = false;
         var req;
+        var localTimeoutMs = opts.localTimeoutMs;
         if (localTimeoutMs) {
             timeoutId = callbacks.setTimeout(function() {
                 timedOut = true;
@@ -486,8 +651,9 @@ module.exports.MatrixHttpApi.prototype = {
                     withCredentials: false,
                     qs: queryParams,
                     body: data,
-                    json: true,
+                    json: json,
                     timeout: localTimeoutMs,
+                    headers: opts.headers || {},
                     _matrix_opts: this.opts
                 },
                 function(err, response, body) {
@@ -497,7 +663,15 @@ module.exports.MatrixHttpApi.prototype = {
                             return; // already rejected promise
                         }
                     }
-                    var handlerFn = requestCallback(defer, callback, self.opts.onlyData);
+
+                    // if json is falsy, we won't parse any error response, so need
+                    // to do so before turning it into a MatrixError
+                    var parseErrorJson = !json;
+                    var handlerFn = requestCallback(
+                        defer, callback, self.opts.onlyData,
+                        parseErrorJson,
+                        opts.bodyParser
+                    );
                     handlerFn(err, response, body);
                 }
             );
@@ -524,14 +698,34 @@ module.exports.MatrixHttpApi.prototype = {
  *
  * If onlyData is true, the defer/callback is invoked with the body of the
  * response, otherwise the result code.
+ *
+ * If parseErrorJson is true, we will JSON.parse the body if we get a 4xx error.
+ *
  */
-var requestCallback = function(defer, userDefinedCallback, onlyData) {
+var requestCallback = function(
+    defer, userDefinedCallback, onlyData,
+    parseErrorJson, bodyParser
+) {
     userDefinedCallback = userDefinedCallback || function() {};
 
     return function(err, response, body) {
-        if (!err && response.statusCode >= 400) {
-            err = new module.exports.MatrixError(body);
-            err.httpStatus = response.statusCode;
+        if (!err) {
+            try {
+                if (response.statusCode >= 400) {
+                    if (parseErrorJson) {
+                        // we won't have json-decoded the response.
+                        body = JSON.parse(body);
+                    }
+                    err = new module.exports.MatrixError(body);
+                } else if (bodyParser) {
+                    body = bodyParser(body);
+                }
+            } catch (e) {
+                err = e;
+            }
+            if (err) {
+                err.httpStatus = response.statusCode;
+            }
         }
 
         if (err) {

lib/models/event.js

@@ -54,6 +54,12 @@ module.exports.EventStatus = {
  * @param {Object=} clearEvent For encrypted events, the plaintext payload for
  * the event (typically containing <tt>type</tt> and <tt>content</tt> fields).
  *
+ * @param {Object=} keysProved Keys owned by the sender of this event.
+ *    See {@link module:models/event.MatrixEvent#getKeysProved}.
+ *
+ * @param {Object=} keysClaimed Keys the sender of this event claims.
+ *    See {@link module:models/event.MatrixEvent#getKeysClaimed}.
+ *
  * @prop {Object} event The raw (possibly encrypted) event. <b>Do not access
  * this property</b> directly unless you absolutely have to. Prefer the getter
  * methods defined on this class. Using the getter methods shields your app
@@ -68,7 +74,9 @@ module.exports.EventStatus = {
  * that getDirectionalContent() will return event.content and not event.prev_content.
  * Default: true. <strong>This property is experimental and may change.</strong>
  */
-module.exports.MatrixEvent = function MatrixEvent(event, clearEvent) {
+module.exports.MatrixEvent = function MatrixEvent(
+    event, clearEvent, keysProved, keysClaimed
+) {
     this.event = event || {};
     this.sender = null;
     this.target = null;
@@ -77,6 +85,9 @@ module.exports.MatrixEvent = function MatrixEvent(event, clearEvent) {
 
     this._clearEvent = clearEvent || {};
     this._pushActions = null;
+
+    this._keysProved = keysProved || {};
+    this._keysClaimed = keysClaimed || {};
 };
 
 module.exports.MatrixEvent.prototype = {
@@ -214,8 +225,9 @@ module.exports.MatrixEvent.prototype = {
      * <tt>"m.room.encrypted"</tt>
      *
      * @param {object} crypto_content raw 'content' for the encrypted event.
+     * @param {object} keys The local keys claimed and proved by this event.
      */
-    makeEncrypted: function(crypto_type, crypto_content) {
+    makeEncrypted: function(crypto_type, crypto_content, keys) {
         // keep the plain-text data for 'view source'
         this._clearEvent = {
             type: this.event.type,
@@ -223,6 +235,8 @@ module.exports.MatrixEvent.prototype = {
         };
         this.event.type = crypto_type;
         this.event.content = crypto_content;
+        this._keysProved = keys;
+        this._keysClaimed = keys;
     },
 
     /**
@@ -233,12 +247,38 @@ module.exports.MatrixEvent.prototype = {
         return Boolean(this._clearEvent.type);
     },
 
+    /**
+     * The curve25519 key that sent this event
+     * @return {string}
+     */
     getSenderKey: function() {
-        if (!this.isEncrypted()) {
-            return null;
-        }
-        var c = this.getWireContent();
-        return c.sender_key;
+        return this.getKeysProved().curve25519 || null;
+    },
+
+    /**
+     * The keys that must have been owned by the sender of this encrypted event.
+     * <p>
+     * These don't necessarily have to come from this event itself, but may be
+     * implied by the cryptographic session.
+     *
+     * @return {Object<string, string>}
+     */
+    getKeysProved: function() {
+        return this._keysProved;
+    },
+
+    /**
+     * The additional keys the sender of this encrypted event claims to possess.
+     * <p>
+     * These don't necessarily have to come from this event itself, but may be
+     * implied by the cryptographic session.
+     * For example megolm messages don't claim keys directly, but instead
+     * inherit a claim from the olm message that established the session.
+     *
+     * @return {Object<string, string>}
+     */
+    getKeysClaimed: function() {
+        return this._keysClaimed;
     },
 
     getUnsigned: function() {

lib/models/room-member.js

@@ -212,21 +212,6 @@ function calculateDisplayName(member, event, roomState) {
     var displayName = event.getDirectionalContent().displayname;
     var selfUserId = member.userId;
 
-    /*
-    // FIXME: this would be great but still needs to use the
-    // full userId to disambiguate if needed...
-
-    if (!displayName) {
-        var matches = selfUserId.match(/^@(.*?):/);
-        if (matches) {
-            return matches[1];
-        }
-        else {
-            return selfUserId;
-        }
-    }
-    */
-
     if (!displayName) {
         return selfUserId;
     }

lib/models/user.js

@@ -47,6 +47,7 @@ function User(userId) {
     this.presence = "offline";
     this.presenceStatusMsg = null;
     this.displayName = userId;
+    this.rawDisplayName = userId;
     this.avatarUrl = null;
     this.lastActiveAgo = 0;
     this.lastPresenceTs = 0;
@@ -131,6 +132,17 @@ User.prototype.setDisplayName = function(name) {
     }
 };
 
+
+/**
+ * Manually set this user's non-disambiguated display name. No event is emitted
+ * in response to this as there is no underlying MatrixEvent to emit with.
+ * @param {string} name The new display name.
+ */
+User.prototype.setRawDisplayName = function(name) {
+    this.rawDisplayName = name;
+};
+
+
 /**
  * Manually set this user's avatar URL. No event is emitted in response to this
  * as there is no underlying MatrixEvent to emit with.

lib/store/memory.js

@@ -101,6 +101,11 @@ module.exports.MatrixInMemoryStore.prototype = {
         var user = this.users[member.userId] || new User(member.userId);
         if (member.name) {
             user.setDisplayName(member.name);
+            if (member.events.member) {
+                user.setRawDisplayName(
+                    member.events.member.getDirectionalContent().displayname
+                );
+            }
         }
         if (member.events.member && member.events.member.getContent().avatar_url) {
             user.setAvatarUrl(member.events.member.getContent().avatar_url);

lib/sync.js

@@ -66,7 +66,6 @@ function SyncApi(client, opts) {
     opts.pendingEventOrdering = opts.pendingEventOrdering || "chronological";
     this.opts = opts;
     this._peekRoomId = null;
-    this._syncConnectionLost = false;
     this._currentSyncRequest = null;
     this._syncState = null;
     this._running = false;
@@ -491,7 +490,7 @@ SyncApi.prototype._sync = function(syncOptions) {
         qps._cacheBuster = Date.now();
     }
 
-    if (self._syncConnectionLost) {
+    if (this.getSyncState() == 'ERROR' || this.getSyncState() == 'RECONNECTING') {
         // we think the connection is dead. If it comes back up, we won't know
         // about it till /sync returns. If the timeout= is high, this could
         // be a long time. Set it to 0 when doing retries so we don't have to wait
@@ -507,8 +506,6 @@ SyncApi.prototype._sync = function(syncOptions) {
     );
 
     this._currentSyncRequest.done(function(data) {
-        self._syncConnectionLost = false;
-
         // set the sync token NOW *before* processing the events. We do this so
         // if something barfs on an event we can skip it rather than constantly
         // polling with the same token.
@@ -546,12 +543,18 @@ SyncApi.prototype._sync = function(syncOptions) {
         console.error(err);
 
         debuglog("Starting keep-alive");
-        self._syncConnectionLost = true;
+        // Note that we do *not* mark the sync connection as
+        // lost yet: we only do this if a keepalive poke
+        // fails, since long lived HTTP connections will
+        // go away sometimes and we shouldn't treat this as
+        // erroneous. We set the state to 'reconnecting'
+        // instead, so that clients can onserve this state
+        // if they wish.
         self._startKeepAlives().done(function() {
             self._sync(syncOptions);
         });
         self._currentSyncRequest = null;
-        self._updateSyncState("ERROR", { error: err });
+        self._updateSyncState("RECONNECTING");
     });
 };
 
@@ -844,17 +847,21 @@ SyncApi.prototype._processSyncResponse = function(syncToken, data) {
  */
 SyncApi.prototype._startKeepAlives = function(delay) {
     if (delay === undefined) {
-        delay = 5000 + Math.floor(Math.random() * 5000);
+        delay = 2000 + Math.floor(Math.random() * 5000);
     }
 
     if (this._keepAliveTimer !== null) {
         clearTimeout(this._keepAliveTimer);
     }
     var self = this;
-    self._keepAliveTimer = setTimeout(
-        self._pokeKeepAlive.bind(self),
-        delay
-    );
+    if (delay > 0) {
+        self._keepAliveTimer = setTimeout(
+            self._pokeKeepAlive.bind(self),
+            delay
+        );
+    } else {
+        self._pokeKeepAlive();
+    }
     if (!this._connectionReturnedDefer) {
         this._connectionReturnedDefer = q.defer();
     }
@@ -874,9 +881,15 @@ SyncApi.prototype._pokeKeepAlive = function() {
         }
     }
 
-    this.client._http.requestWithPrefix(
-        undefined, "GET", "/_matrix/client/versions", undefined,
-        undefined, "", 15 * 1000
+    this.client._http.request(
+        undefined, // callback
+        "GET", "/_matrix/client/versions",
+        undefined, // queryParams
+        undefined, // data
+        {
+            prefix: '',
+            localTimeoutMs: 15 * 1000,
+        }
     ).done(function() {
         success();
     }, function(err) {
@@ -892,6 +905,13 @@ SyncApi.prototype._pokeKeepAlive = function() {
                 self._pokeKeepAlive.bind(self),
                 5000 + Math.floor(Math.random() * 5000)
             );
+            // A keepalive has failed, so we emit the
+            // error state (whether or not this is the
+            // first failure).
+            // Note we do this after setting the timer:
+            // this lets the unit tests advance the mock
+            // clock when the get the error.
+            self._updateSyncState("ERROR", { error: err });
         }
     });
 };

package.json

@@ -1,6 +1,6 @@
 {
   "name": "matrix-js-sdk",
-  "version": "0.5.6",
+  "version": "0.6.3",
   "description": "Matrix Client-Server SDK for Javascript",
   "main": "index.js",
   "scripts": {
@@ -39,6 +39,6 @@
     "uglifyjs": "^2.4.10"
   },
   "optionalDependencies": {
-    "olm": "https://matrix.org/packages/npm/olm/olm-1.2.0.tgz"
+    "olm": "https://matrix.org/packages/npm/olm/olm-1.3.0.tgz"
   }
 }

release.sh

@@ -3,8 +3,10 @@
 # Script to perform a release of matrix-js-sdk. Performs the steps documented
 # in RELEASING.md
 #
-# Requires github-changelog-generator; to install, do
-#   pip install git+https://github.com/matrix-org/github-changelog-generator.git
+# Requires:
+#   github-changelog-generator; to install, do
+#     pip install git+https://github.com/matrix-org/github-changelog-generator.git
+#   jq; install from your distibution's package manager (https://stedolan.github.io/jq/)
 
 set -e
 
@@ -20,6 +22,13 @@ $USAGE
 EOF
 }
 
+ret=0
+cat package.json | jq '.dependencies[]' | grep -q '#develop' || ret=$?
+if [ "$ret" -eq 0 ]; then
+    echo "package.json contains develop dependencies. Refusing to release."
+    exit
+fi
+
 skip_changelog=
 skip_jsdoc=
 changelog_file="CHANGELOG.md"

spec/integ/matrix-client-methods.spec.js

@@ -37,6 +37,117 @@ describe("MatrixClient", function() {
         httpBackend.verifyNoOutstandingExpectation();
     });
 
+    describe("uploadContent", function() {
+        var buf = new Buffer('hello world');
+        it("should upload the file", function(done) {
+            httpBackend.when(
+                "POST", "/_matrix/media/v1/upload"
+            ).check(function(req) {
+                expect(req.data).toEqual(buf);
+                expect(req.queryParams.filename).toEqual("hi.txt");
+                expect(req.queryParams.access_token).toEqual(accessToken);
+                expect(req.headers["Content-Type"]).toEqual("text/plain");
+                expect(req.opts.json).toBeFalsy();
+                expect(req.opts.timeout).toBe(undefined);
+            }).respond(200, "content");
+
+            var prom = client.uploadContent({
+                stream: buf,
+                name: "hi.txt",
+                type: "text/plain",
+            });
+
+            expect(prom).toBeDefined();
+
+            var uploads = client.getCurrentUploads();
+            expect(uploads.length).toEqual(1);
+            expect(uploads[0].promise).toBe(prom);
+            expect(uploads[0].loaded).toEqual(0);
+
+            prom.then(function(response) {
+                // for backwards compatibility, we return the raw JSON
+                expect(response).toEqual("content");
+
+                var uploads = client.getCurrentUploads();
+                expect(uploads.length).toEqual(0);
+            }).catch(utils.failTest).done(done);
+
+            httpBackend.flush();
+        });
+
+        it("should parse the response if rawResponse=false", function(done) {
+            httpBackend.when(
+                "POST", "/_matrix/media/v1/upload"
+            ).check(function(req) {
+                expect(req.opts.json).toBeFalsy();
+            }).respond(200, JSON.stringify({ "content_uri": "uri" }));
+
+            client.uploadContent({
+                stream: buf,
+                name: "hi.txt",
+                type: "text/plain",
+            }, {
+                rawResponse: false,
+            }).then(function(response) {
+                expect(response.content_uri).toEqual("uri");
+            }).catch(utils.failTest).done(done);
+
+            httpBackend.flush();
+        });
+
+        it("should parse errors into a MatrixError", function(done) {
+            // opts.json is false, so request returns unparsed json.
+            httpBackend.when(
+                "POST", "/_matrix/media/v1/upload"
+            ).check(function(req) {
+                expect(req.data).toEqual(buf);
+                expect(req.opts.json).toBeFalsy();
+            }).respond(400, JSON.stringify({
+                "errcode": "M_SNAFU",
+                "error": "broken",
+            }));
+
+            client.uploadContent({
+                stream: buf,
+                name: "hi.txt",
+                type: "text/plain",
+            }).then(function(response) {
+                throw Error("request not failed");
+            }, function(error) {
+                expect(error.httpStatus).toEqual(400);
+                expect(error.errcode).toEqual("M_SNAFU");
+                expect(error.message).toEqual("broken");
+            }).catch(utils.failTest).done(done);
+
+            httpBackend.flush();
+        });
+
+        it("should return a promise which can be cancelled", function(done) {
+            var prom = client.uploadContent({
+                stream: buf,
+                name: "hi.txt",
+                type: "text/plain",
+            });
+
+            var uploads = client.getCurrentUploads();
+            expect(uploads.length).toEqual(1);
+            expect(uploads[0].promise).toBe(prom);
+            expect(uploads[0].loaded).toEqual(0);
+
+            prom.then(function(response) {
+                throw Error("request not aborted");
+            }, function(error) {
+                expect(error).toEqual("aborted");
+
+                var uploads = client.getCurrentUploads();
+                expect(uploads.length).toEqual(0);
+            }).catch(utils.failTest).done(done);
+
+            var r = client.cancelUpload(prom);
+            expect(r).toBe(true);
+        });
+    });
+
     describe("joinRoom", function() {
         it("should no-op if you've already joined a room", function() {
             var roomId = "!foo:bar";

spec/mock-request.js

@@ -11,18 +11,17 @@ function HttpBackend() {
     var self = this;
     // the request function dependency that the SDK needs.
     this.requestFn = function(opts, callback) {
-        var realReq = new Request(opts.method, opts.uri, opts.body, opts.qs);
-        realReq.callback = callback;
-        console.log("HTTP backend received request: %s %s", opts.method, opts.uri);
-        self.requests.push(realReq);
+        var req = new Request(opts, callback);
+        console.log("HTTP backend received request: %s", req);
+        self.requests.push(req);
 
         var abort = function() {
-            var idx = self.requests.indexOf(realReq);
+            var idx = self.requests.indexOf(req);
             if (idx >= 0) {
                 console.log("Aborting HTTP request: %s %s", opts.method,
                             opts.uri);
                 self.requests.splice(idx, 1);
-                realReq.callback("aborted");
+                req.callback("aborted");
             }
         };
 
@@ -161,22 +160,32 @@ HttpBackend.prototype = {
      * @return {Request} An expected request.
      */
     when: function(method, path, data) {
-        var pendingReq = new Request(method, path, data);
+        var pendingReq = new ExpectedRequest(method, path, data);
         this.expectedRequests.push(pendingReq);
         return pendingReq;
     }
 };
 
-function Request(method, path, data, queryParams) {
+/**
+ * Represents the expectation of a request.
+ *
+ * <p>Includes the conditions to be matched against, the checks to be made,
+ * and the response to be returned.
+ *
+ * @constructor
+ * @param {string} method
+ * @param {string} path
+ * @param {object?} data
+ */
+function ExpectedRequest(method, path, data) {
     this.method = method;
     this.path = path;
     this.data = data;
-    this.queryParams = queryParams;
-    this.callback = null;
     this.response = null;
     this.checks = [];
 }
-Request.prototype = {
+
+ExpectedRequest.prototype = {
     /**
      * Execute a check when this request has been satisfied.
      * @param {Function} fn The function to execute.
@@ -221,6 +230,44 @@ Request.prototype = {
     }
 };
 
+/**
+ * Represents a request made by the app.
+ *
+ * @constructor
+ * @param {object} opts opts passed to request()
+ * @param {function} callback
+ */
+function Request(opts, callback) {
+    this.opts = opts;
+    this.callback = callback;
+
+    Object.defineProperty(this, 'method', {
+        get: function() { return opts.method; }
+    });
+
+    Object.defineProperty(this, 'path', {
+        get: function() { return opts.uri; }
+    });
+
+    Object.defineProperty(this, 'data', {
+        get: function() { return opts.body; }
+    });
+
+    Object.defineProperty(this, 'queryParams', {
+        get: function() { return opts.qs; }
+    });
+
+    Object.defineProperty(this, 'headers', {
+        get: function() { return opts.headers || {}; }
+    });
+}
+
+Request.prototype = {
+    toString: function() {
+        return this.method + " " + this.path;
+    },
+};
+
 /**
  * The HttpBackend class.
  */

spec/unit/crypto.spec.js

@@ -0,0 +1,14 @@
+
+"use strict";
+var Crypto = require("../../lib/crypto");
+var sdk = require("../..");
+
+describe("Crypto", function() {
+    if (!sdk.CRYPTO_ENABLED) {
+        return;
+    }
+
+    it("Crypto exposes the correct olm library version", function() {
+        expect(Crypto.getOlmVersion()).toEqual([1, 3, 0]);
+    });
+});

spec/unit/matrix-client.spec.js

@@ -51,9 +51,10 @@ describe("MatrixClient", function() {
         // }
         // items are popped off when processed and block if no items left.
     ];
+    var accept_keepalives;
     var pendingLookup = null;
     function httpReq(cb, method, path, qp, data, prefix) {
-        if (path === KEEP_ALIVE_PATH) {
+        if (path === KEEP_ALIVE_PATH && accept_keepalives) {
             return q();
         }
         var next = httpLookups.shift();
@@ -143,8 +144,10 @@ describe("MatrixClient", function() {
         client._http.authedRequest.andCallFake(httpReq);
         client._http.authedRequestWithPrefix.andCallFake(httpReq);
         client._http.requestWithPrefix.andCallFake(httpReq);
+        client._http.request.andCallFake(httpReq);
 
         // set reasonable working defaults
+        accept_keepalives = true;
         pendingLookup = null;
         httpLookups = [];
         httpLookups.push(PUSH_RULES_RESPONSE);
@@ -250,6 +253,8 @@ describe("MatrixClient", function() {
                         true, "retryImmediately returned false"
                     );
                     jasmine.Clock.tick(1);
+                } else if (state === "RECONNECTING" && httpLookups.length > 0) {
+                    jasmine.Clock.tick(10000);
                 } else if (state === "SYNCING" && httpLookups.length === 0) {
                     client.removeListener("sync", syncListener);
                     done();
@@ -329,17 +334,25 @@ describe("MatrixClient", function() {
         it("should transition ERROR -> PREPARED after /sync if prev failed",
         function(done) {
             var expectedStates = [];
+            accept_keepalives = false;
             httpLookups = [];
             httpLookups.push(PUSH_RULES_RESPONSE);
             httpLookups.push(FILTER_RESPONSE);
             httpLookups.push({
                 method: "GET", path: "/sync", error: { errcode: "NOPE_NOPE_NOPE" }
             });
+            httpLookups.push({
+                method: "GET", path: KEEP_ALIVE_PATH, error: { errcode: "KEEPALIVE_FAIL" }
+            });
+            httpLookups.push({
+                method: "GET", path: KEEP_ALIVE_PATH, data: {}
+            });
             httpLookups.push({
                 method: "GET", path: "/sync", data: SYNC_DATA
             });
 
-            expectedStates.push(["ERROR", null]);
+            expectedStates.push(["RECONNECTING", null]);
+            expectedStates.push(["ERROR", "RECONNECTING"]);
             expectedStates.push(["PREPARED", "ERROR"]);
             client.on("sync", syncChecker(expectedStates, done));
             client.startClient();
@@ -354,14 +367,19 @@ describe("MatrixClient", function() {
         });
 
         it("should transition SYNCING -> ERROR after a failed /sync", function(done) {
+            accept_keepalives = false;
             var expectedStates = [];
             httpLookups.push({
                 method: "GET", path: "/sync", error: { errcode: "NONONONONO" }
             });
+            httpLookups.push({
+                method: "GET", path: KEEP_ALIVE_PATH, error: { errcode: "KEEPALIVE_FAIL" }
+            });
 
             expectedStates.push(["PREPARED", null]);
             expectedStates.push(["SYNCING", "PREPARED"]);
-            expectedStates.push(["ERROR", "SYNCING"]);
+            expectedStates.push(["RECONNECTING", "SYNCING"]);
+            expectedStates.push(["ERROR", "RECONNECTING"]);
             client.on("sync", syncChecker(expectedStates, done));
             client.startClient();
         });
@@ -394,18 +412,23 @@ describe("MatrixClient", function() {
             client.startClient();
         });
 
-        it("should transition ERROR -> ERROR if multiple /sync fails", function(done) {
+        it("should transition ERROR -> ERROR if keepalive keeps failing", function(done) {
+            accept_keepalives = false;
             var expectedStates = [];
             httpLookups.push({
                 method: "GET", path: "/sync", error: { errcode: "NONONONONO" }
             });
             httpLookups.push({
-                method: "GET", path: "/sync", error: { errcode: "NONONONONO" }
+                method: "GET", path: KEEP_ALIVE_PATH, error: { errcode: "KEEPALIVE_FAIL" }
+            });
+            httpLookups.push({
+                method: "GET", path: KEEP_ALIVE_PATH, error: { errcode: "KEEPALIVE_FAIL" }
             });
 
             expectedStates.push(["PREPARED", null]);
             expectedStates.push(["SYNCING", "PREPARED"]);
-            expectedStates.push(["ERROR", "SYNCING"]);
+            expectedStates.push(["RECONNECTING", "SYNCING"]);
+            expectedStates.push(["ERROR", "RECONNECTING"]);
             expectedStates.push(["ERROR", "ERROR"]);
             client.on("sync", syncChecker(expectedStates, done));
             client.startClient();