matrix-js-sdk 31.2.0 → 31.3.0-rc.0

package/lib/client.js

@@ -186,7 +186,12 @@ class MatrixClient extends _typedEventEmitter.TypedEventEmitter {
     (0, _defineProperty2.default)(this, "turnServersExpiry", 0);
     (0, _defineProperty2.default)(this, "txnCtr", 0);
     (0, _defineProperty2.default)(this, "mediaHandler", new _mediaHandler.MediaHandler(this));
-    (0, _defineProperty2.default)(this, "pendingEventEncryption", new Map());
+    /** IDs of events which are currently being encrypted.
+     *
+     * This is part of the cancellation mechanism: if the event is no longer listed here when encryption completes,
+     * that tells us that it has been cancelled, and we should not send it.
+     */
+    (0, _defineProperty2.default)(this, "eventsBeingEncrypted", new Set());
     (0, _defineProperty2.default)(this, "useE2eForGroupCall", true);
     (0, _defineProperty2.default)(this, "startCallEventHandler", () => {
       if (this.isInitialSyncComplete()) {
@@ -327,7 +332,7 @@ class MatrixClient extends _typedEventEmitter.TypedEventEmitter {
     // correctly handle notification counts on encrypted rooms.
     // This fixes https://github.com/vector-im/element-web/issues/9421
     this.on(_room.RoomEvent.Receipt, (event, room) => {
-      if (room && this.isRoomEncrypted(room.roomId)) {
+      if (room !== null && room !== void 0 && room.hasEncryptionStateEvent()) {
         // Figure out if we've read something or if it's just informational
         const content = event.getContent();
         const isSelf = Object.keys(content).filter(eid => {
@@ -1099,7 +1104,7 @@ class MatrixClient extends _typedEventEmitter.TypedEventEmitter {
     });
 
     // re-emit the events emitted by the crypto impl
-    this.reEmitter.reEmit(rustCrypto, [_crypto.CryptoEvent.VerificationRequestReceived, _crypto.CryptoEvent.UserTrustStatusChanged, _crypto.CryptoEvent.KeyBackupStatus, _crypto.CryptoEvent.KeyBackupSessionsRemaining, _crypto.CryptoEvent.KeyBackupFailed, _crypto.CryptoEvent.KeyBackupDecryptionKeyCached]);
+    this.reEmitter.reEmit(rustCrypto, [_crypto.CryptoEvent.VerificationRequestReceived, _crypto.CryptoEvent.UserTrustStatusChanged, _crypto.CryptoEvent.KeyBackupStatus, _crypto.CryptoEvent.KeyBackupSessionsRemaining, _crypto.CryptoEvent.KeyBackupFailed, _crypto.CryptoEvent.KeyBackupDecryptionKeyCached, _crypto.CryptoEvent.KeysChanged, _crypto.CryptoEvent.DevicesUpdated, _crypto.CryptoEvent.WillUpdateDevices]);
   }
 
   /**
@@ -1977,6 +1982,9 @@ class MatrixClient extends _typedEventEmitter.TypedEventEmitter {
    * @param roomId - The room ID to enable encryption in.
    * @param config - The encryption config for the room.
    * @returns A promise that will resolve when encryption is set up.
+   *
+   * @deprecated Not supported for Rust Cryptography. To enable encryption in a room, send an `m.room.encryption`
+   * state event.
    */
   setRoomEncryption(roomId, config) {
     if (!this.crypto) {
@@ -1989,6 +1997,9 @@ class MatrixClient extends _typedEventEmitter.TypedEventEmitter {
    * Whether encryption is enabled for a room.
    * @param roomId - the room id to query.
    * @returns whether encryption is enabled.
+   *
+   * @deprecated Not correctly supported for Rust Cryptography. Use {@link CryptoApi.isEncryptionEnabledInRoom} and/or
+   *    {@link Room.hasEncryptionStateEvent}.
    */
   isRoomEncrypted(roomId) {
     var _this$crypto$isRoomEn, _this$crypto3;
@@ -2001,8 +2012,7 @@ class MatrixClient extends _typedEventEmitter.TypedEventEmitter {
 
     // if there is an 'm.room.encryption' event in this room, it should be
     // encrypted (independently of whether we actually support encryption)
-    const ev = room.currentState.getStateEvents(_event2.EventType.RoomEncryption, "");
-    if (ev) {
+    if (room.hasEncryptionStateEvent()) {
       return true;
     }
 
@@ -2995,9 +3005,10 @@ class MatrixClient extends _typedEventEmitter.TypedEventEmitter {
       throw new Error("cannot cancel an event with status " + event.status);
     }
 
-    // if the event is currently being encrypted then
+    // If the event is currently being encrypted then remove it from the pending list, to indicate that it should
+    // not be sent.
     if (event.status === _event.EventStatus.ENCRYPTING) {
-      this.pendingEventEncryption.delete(event.getId());
+      this.eventsBeingEncrypted.delete(event.getId());
     } else if (this.scheduler && event.status === _event.EventStatus.QUEUED) {
       // tell the scheduler to forget about it, if it's queued
       this.scheduler.removeEventFromQueue(event);
@@ -3263,27 +3274,25 @@ class MatrixClient extends _typedEventEmitter.TypedEventEmitter {
    * encrypts the event if necessary; adds the event to the queue, or sends it; marks the event as sent/unsent
    * @returns returns a promise which resolves with the result of the send request
    */
-  encryptAndSendEvent(room, event) {
-    let cancelled = false;
-    // Add an extra Promise.resolve() to turn synchronous exceptions into promise rejections,
-    // so that we can handle synchronous and asynchronous exceptions with the
-    // same code path.
-    return Promise.resolve().then(() => {
-      const encryptionPromise = this.encryptEventIfNeeded(event, room !== null && room !== void 0 ? room : undefined);
-      if (!encryptionPromise) return null; // doesn't need encryption
-
-      this.pendingEventEncryption.set(event.getId(), encryptionPromise);
-      this.updatePendingEventStatus(room, event, _event.EventStatus.ENCRYPTING);
-      return encryptionPromise.then(() => {
-        if (!this.pendingEventEncryption.has(event.getId())) {
-          // cancelled via MatrixClient::cancelPendingEvent
-          cancelled = true;
-          return;
-        }
+  async encryptAndSendEvent(room, event) {
+    try {
+      let cancelled;
+      this.eventsBeingEncrypted.add(event.getId());
+      try {
+        await this.encryptEventIfNeeded(event, room !== null && room !== void 0 ? room : undefined);
+      } finally {
+        cancelled = !this.eventsBeingEncrypted.delete(event.getId());
+      }
+      if (cancelled) {
+        // cancelled via MatrixClient::cancelPendingEvent
+        return {};
+      }
+
+      // encryptEventIfNeeded may have updated the status from SENDING to ENCRYPTING. If so, we need
+      // to put it back.
+      if (event.status === _event.EventStatus.ENCRYPTING) {
         this.updatePendingEventStatus(room, event, _event.EventStatus.SENDING);
-      });
-    }).then(() => {
-      if (cancelled) return {};
+      }
       let promise = null;
       if (this.scheduler) {
         // if this returns a promise then the scheduler has control now and will
@@ -3306,9 +3315,9 @@ class MatrixClient extends _typedEventEmitter.TypedEventEmitter {
           });
         }
       }
-      return promise;
-    }).catch(err => {
-      this.logger.error("Error sending event", err.stack || err);
+      return await promise;
+    } catch (err) {
+      this.logger.error("Error sending event", err);
       try {
         // set the error on the event before we update the status:
         // updating the status emits the event, so the state should be
@@ -3316,34 +3325,43 @@ class MatrixClient extends _typedEventEmitter.TypedEventEmitter {
         event.error = err;
         this.updatePendingEventStatus(room, event, _event.EventStatus.NOT_SENT);
       } catch (e) {
-        this.logger.error("Exception in error handler!", e.stack || err);
+        this.logger.error("Exception in error handler!", e);
       }
       if (err instanceof _httpApi.MatrixError) {
         err.event = event;
       }
       throw err;
-    });
+    }
+  }
+  async encryptEventIfNeeded(event, room) {
+    // If the room is unknown, we cannot encrypt for it
+    if (!room) return;
+    if (!(await this.shouldEncryptEventForRoom(event, room))) return;
+    if (!this.cryptoBackend && this.usingExternalCrypto) {
+      // The client has opted to allow sending messages to encrypted
+      // rooms even if the room is encrypted, and we haven't set up
+      // crypto. This is useful for users of matrix-org/pantalaimon
+      return;
+    }
+    if (!this.cryptoBackend) {
+      throw new Error("This room is configured to use encryption, but your client does not support encryption.");
+    }
+    this.updatePendingEventStatus(room, event, _event.EventStatus.ENCRYPTING);
+    await this.cryptoBackend.encryptEvent(event, room);
   }
-  encryptEventIfNeeded(event, room) {
+
+  /**
+   * Determine whether a given event should be encrypted when we send it to the given room.
+   *
+   * This takes into account event type and room configuration.
+   */
+  async shouldEncryptEventForRoom(event, room) {
+    var _this$cryptoBackend2;
     if (event.isEncrypted()) {
       // this event has already been encrypted; this happens if the
       // encryption step succeeded, but the send step failed on the first
       // attempt.
-      return null;
-    }
-    if (event.isRedaction()) {
-      // Redactions do not support encryption in the spec at this time,
-      // whilst it mostly worked in some clients, it wasn't compliant.
-      return null;
-    }
-    if (!room || !this.isRoomEncrypted(event.getRoomId())) {
-      return null;
-    }
-    if (!this.cryptoBackend && this.usingExternalCrypto) {
-      // The client has opted to allow sending messages to encrypted
-      // rooms even if the room is encrypted, and we haven't setup
-      // crypto. This is useful for users of matrix-org/pantalaimon
-      return null;
+      return false;
     }
     if (event.getType() === _event2.EventType.Reaction) {
       // For reactions, there is a very little gained by encrypting the entire
@@ -3356,12 +3374,22 @@ class MatrixClient extends _typedEventEmitter.TypedEventEmitter {
       // The reaction key / content / emoji value does warrant encrypting, but
       // this will be handled separately by encrypting just this value.
       // See https://github.com/matrix-org/matrix-doc/pull/1849#pullrequestreview-248763642
-      return null;
+      return false;
     }
-    if (!this.cryptoBackend) {
-      throw new Error("This room is configured to use encryption, but your client does not support encryption.");
+    if (event.isRedaction()) {
+      // Redactions do not support encryption in the spec at this time.
+      // Whilst it mostly worked in some clients, it wasn't compliant.
+      return false;
     }
-    return this.cryptoBackend.encryptEvent(event, room);
+
+    // If the room has an m.room.encryption event, we should encrypt.
+    if (room.hasEncryptionStateEvent()) return true;
+
+    // If we have a crypto impl, and *it* thinks we should encrypt, then we should.
+    if (await ((_this$cryptoBackend2 = this.cryptoBackend) === null || _this$cryptoBackend2 === void 0 ? void 0 : _this$cryptoBackend2.isEncryptionEnabledInRoom(room.roomId))) return true;
+
+    // Otherwise, no need to encrypt.
+    return false;
   }
 
   /**
@@ -3372,8 +3400,9 @@ class MatrixClient extends _typedEventEmitter.TypedEventEmitter {
    * @returns the event type taking encryption into account
    */
   getEncryptedIfNeededEventType(roomId, eventType) {
+    var _this$getRoom3;
     if (eventType === _event2.EventType.Reaction) return eventType;
-    return this.isRoomEncrypted(roomId) ? _event2.EventType.RoomMessageEncrypted : eventType;
+    return (_this$getRoom3 = this.getRoom(roomId)) !== null && _this$getRoom3 !== void 0 && _this$getRoom3.hasEncryptionStateEvent() ? _event2.EventType.RoomMessageEncrypted : eventType;
   }
   updatePendingEventStatus(room, event, newStatus) {
     if (room) {
@@ -4120,10 +4149,13 @@ class MatrixClient extends _typedEventEmitter.TypedEventEmitter {
    * @param allowDirectLinks - If true, return any non-mxc URLs
    * directly. Fetching such URLs will leak information about the user to
    * anyone they share a room with. If false, will return null for such URLs.
+   * @param allowRedirects - If true, the caller supports the URL being 307 or
+   * 308 redirected to another resource upon request. If false, redirects
+   * are not expected.
    * @returns the avatar URL or null.
    */
-  mxcUrlToHttp(mxcUrl, width, height, resizeMethod, allowDirectLinks) {
-    return (0, _contentRepo.getHttpUriForMxc)(this.baseUrl, mxcUrl, width, height, resizeMethod, allowDirectLinks);
+  mxcUrlToHttp(mxcUrl, width, height, resizeMethod, allowDirectLinks, allowRedirects) {
+    return (0, _contentRepo.getHttpUriForMxc)(this.baseUrl, mxcUrl, width, height, resizeMethod, allowDirectLinks, allowRedirects);
   }
 
   /**