Enum UtdCause

pub enum UtdCause {
    Unknown = 0,
    SentBeforeWeJoined = 1,
    VerificationViolation = 2,
    UnsignedDevice = 3,
    UnknownDevice = 4,
    HistoricalMessageAndBackupIsDisabled = 5,
    WithheldForUnverifiedOrInsecureDevice = 6,
    WithheldBySender = 7,
    HistoricalMessageAndDeviceIsUnverified = 8,
}

Our best guess at the reason why an event can’t be decrypted.

Variants

Unknown = 0

We don’t have an explanation for why this UTD happened - it is probably a bug, or a network split between the two homeservers.

For example:

• the keys for this event are missing, but a key storage backup exists and is working, so we should be able to find the keys in the backup.

• the keys for this event are missing, and a key storage backup exists on the server, but that backup is not working on this client even though this device is verified.

SentBeforeWeJoined = 1

We are missing the keys for this event, and the event was sent when we were not a member of the room (or invited).

VerificationViolation = 2

The message was sent by a user identity we have not verified, but the user was previously verified.

UnsignedDevice = 3

The crate::TrustRequirement requires that the sending device be signed by its owner, and it was not.

UnknownDevice = 4

The crate::TrustRequirement requires that the sending device be signed by its owner, and we were unable to securely find the device.

This could be because the device has since been deleted, because we haven’t yet downloaded it from the server, or because the session data was obtained from an insecure source (imported from a file, obtained from a legacy (asymmetric) backup, unsafe key forward, etc.)

HistoricalMessageAndBackupIsDisabled = 5

We are missing the keys for this event, but it is a “device-historical” message and there is no key storage backup on the server, presumably because the user has turned it off.

Device-historical means that the message was sent before the current device existed (but the current user was probably a member of the room at the time the message was sent). Not to be confused with pre-join or pre-invite messages (see UtdCause::SentBeforeWeJoined for that).

Expected message to user: “History is not available on this device”.

WithheldForUnverifiedOrInsecureDevice = 6

The keys for this event are intentionally withheld.

The sender has refused to share the key because our device does not meet the sender’s security requirements.

WithheldBySender = 7

The keys for this event are missing, likely because the sender was unable to share them (e.g., failure to establish an Olm 1:1 channel). Alternatively, the sender may have deliberately excluded this device by cherry-picking and blocking it, in which case, no action can be taken on our side.

HistoricalMessageAndDeviceIsUnverified = 8

We are missing the keys for this event, but it is a “device-historical” message, and even though a key storage backup does exist, we can’t use it because our device is unverified.

Device-historical means that the message was sent before the current device existed (but the current user was probably a member of the room at the time the message was sent). Not to be confused with pre-join or pre-invite messages (see UtdCause::SentBeforeWeJoined for that).

Expected message to user: “You need to verify this device”.

Implementations

impl UtdCause

pub fn determine( raw_event: &Raw<AnySyncTimelineEvent>, crypto_context_info: CryptoContextInfo, unable_to_decrypt_info: &UnableToDecryptInfo, ) -> Self

Decide the cause of this UTD, based on the evidence we have.

Trait Implementations

impl Clone for UtdCause

fn clone(&self) -> UtdCause

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<UT> ConvertError<UT> for UtdCause

fn try_convert_unexpected_callback_error( e: UnexpectedUniFFICallbackError, ) -> Result<Self>

impl Debug for UtdCause

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for UtdCause

fn default() -> UtdCause

Returns the “default value” for a type.

impl<UT> FfiConverter<UT> for UtdCause

const TYPE_ID_META: MetadataBuffer = _

Type ID metadata, serialized into a MetadataBuffer.

type FfiType = RustBuffer

The low-level type used for passing values of this type over the FFI.

fn lower(v: Self) -> RustBuffer

Lower a rust value of the target type, into an FFI value of type Self::FfiType.

fn try_lift(buf: RustBuffer) -> Result<Self>

Lift a rust value of the target type, from an FFI value of type Self::FfiType.

fn write(obj: Self, buf: &mut Vec<u8>)

Write a rust value into a buffer, to send over the FFI in serialized form.

fn try_read(buf: &mut &[u8]) -> Result<Self>

Read a rust value from a buffer, received over the FFI in serialized form.

impl Hash for UtdCause

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<UT> Lift<UT> for UtdCause

type FfiType = <UtdCause as FfiConverter<UT>>::FfiType

fn try_lift(v: Self::FfiType) -> Result<Self>

fn try_read(buf: &mut &[u8]) -> Result<Self>

fn try_lift_from_rust_buffer(v: RustBuffer) -> Result<Self, Error>

Convenience method

impl<UT> LiftRef<UT> for UtdCause

type LiftType = UtdCause

impl<UT> LiftReturn<UT> for UtdCause

type ReturnType = <UtdCause as Lift<UT>>::FfiType

FFI return type for trait interfaces

fn try_lift_successful_return(v: Self::ReturnType) -> Result<Self>

Lift a successfully returned value from a trait interface

fn lift_foreign_return( ffi_return: Self::ReturnType, call_status: RustCallStatus, ) -> Self

Lift a foreign returned value from a trait interface

fn lift_error(_buf: RustBuffer) -> Self

Lift a Rust value for a callback interface method error result

fn handle_callback_unexpected_error(e: UnexpectedUniFFICallbackError) -> Self

Lift a Rust value for an unexpected callback interface error

impl<UT> Lower<UT> for UtdCause

type FfiType = <UtdCause as FfiConverter<UT>>::FfiType

fn lower(obj: Self) -> Self::FfiType

fn write(obj: Self, buf: &mut Vec<u8>)

fn lower_into_rust_buffer(obj: Self) -> RustBuffer

Convenience method

impl<UT> LowerError<UT> for UtdCause

fn lower_error(obj: Self) -> RustBuffer

Lower this value for scaffolding function return

impl<UT> LowerReturn<UT> for UtdCause

type ReturnType = <UtdCause as Lower<UT>>::FfiType

The type that should be returned by scaffolding functions for this type.

fn lower_return(obj: Self) -> Result<Self::ReturnType, RustBuffer>

Lower this value for scaffolding function return

fn handle_failed_lift(arg_name: &str, e: Error) -> Self

If possible, get a serialized error for failed argument lifts

impl PartialEq for UtdCause

fn eq(&self, other: &UtdCause) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<UT> TypeId<UT> for UtdCause

const TYPE_ID_META: MetadataBuffer = _

impl Copy for UtdCause

impl Eq for UtdCause

impl StructuralPartialEq for UtdCause