macltok

public

Star0

Fork 0

Watch0

41 commits 3 branches 0 tags 0 releases3.0 MiB

Commit `0291516d40b5`

tarball

atagen <boss@atagen.co>2026-10-22 09:31 UTC

14 files changed+606-37

link_previews: show senders' msc4095 previews and ask the homeserver for the rest

Sender-attached previews need no request, so they work in encrypted rooms without telling the homeserver every url, but they're the sender's word, so a preview for a url the body doesn't contain is dropped. The homeserver's preview_url is rate limited and timelines repeat links, so answers and misses are cached and concurrent asks share one request. A 429 now classifies as ErrorKind::RateLimited everywhere, not just here.

Modified file: Cargo.toml+1−1

@@ -31,7 +31,7 @@ matrix-sdk-base = { version = "0.18.0", default-features = false }

3131 matrix-sdk-crypto = { version = "0.18.0", default-features = false }

3232 matrix-sdk-store-encryption = { version = "0.18.0", optional = true }

3333 matrix-sdk-ui = { version = "0.18.0", default-features = false }

34-ruma = { version = "0.16.0", default-features = false, features = ["unstable-msc2545"] }

34+ruma = { version = "0.16.0", default-features = false, features = ["unstable-msc2545", "unstable-msc4095"] }

3535 serde = { version = "1.0.219", features = ["derive", "rc"], optional = true }

3636 thiserror = "2.0.16"

3737 mime = "0.3.17"

Modified file: docs/design-decisions.md+31 additions−1 deletions@@ -228,7 +228,12 @@ and `SessionTokensChanged` only goes out once it has landed, or
 `SessionSaveFailed` if it didn't. natively the sdk's save callback runs inside
 the refresh, before the new token is used, and `save_blocking` writes there and
 then. in a browser there's only the async save, so a tab that dies between a
-refresh and its save wakes up holding a spent token. `without_persistence`
+refresh and its save wakes up holding a spent token. a fork patch letting the
+sdk await an async save before it uses the new token would close that, but it
+changes how a refresh behaves rather than what's visible, and on 2026-10-22 we
+held off so the fork doesn't drift that far that fast. upstream taking an async
+save callback, or the fork already carrying behaviour changes, reopens it.
+`without_persistence`
 hands the job back to the host. `EncryptedSessionStore` seals the record with
 the sdk's `StoreCipher` under the store's passphrase and replaces it by rename,
 so a crash mid save leaves the old one. it keeps the record out of the sdk's
@@ -329,6 +334,31 @@ membership until it's forgotten. push rule changes never touch room info, so
 `NotificationSettingsChanged` brings a `RoomsChanged` along for the modes in
 the summaries
 
+## link previews
+
+a text message can carry its sender's own previews (msc4095), and those come
+out on `Message::link_previews` without asking anyone, so they work in
+encrypted rooms and leak nothing. an encrypted preview image is registered like
+an attachment. a preview whose url isn't in the body is dropped, or a sender
+could caption any link with any card
+
+`url_preview` asks the homeserver, which fetches the page, re-hosts `og:image`
+and answers with loose `og:` keys. that tells the homeserver every url, so
+whether encrypted rooms ask is the host's call. answers are kept an hour and
+misses ten minutes, and asks for one url at once share a request, since synapse
+rate limits the endpoint and a timeline repeats links. synapse answers a page
+it couldn't download with a 500, a dns failure with a 502 and its blocklist with
+a 403, so those, 400 and 404 mean no preview. a genuine 500 hides in there too,
+but a missing card is cheap. a
+server that doesn't preview at all says so with `M_UNRECOGNIZED` once and isn't
+asked again. a 429 anywhere is `ErrorKind::RateLimited`. page text from either
+source is trimmed, 256 characters for a title or site name and 1024 for a
+description, and an image that isn't an mxc uri is dropped
+
+`url_previews_allowed` follows element, so both agree. the user's own choice
+for the room, then their account wide default, then room state an admin set.
+the room state comes in with the rest through the fork's extra required state
+
 ## image packs
 
 msc2545 packs come from the user's account data, from room state, and from the

Modified file: src/engine/media.rs+9 additions−3 deletions@@ -31,10 +31,10 @@ use matrix_sdk_crypto::{AttachmentDecryptor, MediaEncryptionInfo};
 use ruma::MxcUri;
 use tokio::sync::Mutex;
 
-use super::executor::EngineBoxFuture;
+use super::{executor::EngineBoxFuture, url_preview::UrlPreviews};
 use crate::{
-    AttachmentEncryption, AttachmentUpload, Error, ErrorKind, Media, MediaFile, MediaId, MediaKind,
-    MediaLocation, MediaSize, TimelineId,
+    AttachmentEncryption, AttachmentUpload, Error, ErrorKind, LinkPreview, Media, MediaFile,
+    MediaId, MediaKind, MediaLocation, MediaSize, TimelineId,
     normalise::{MediaRegistration, MediaScope, MediaSourceInfo},
     upload::prepare_upload,
 };
@@ -54,11 +54,13 @@ pub(crate) struct MediaService {
     registry: Mutex<MediaRegistry>,
     flights: Mutex<HashMap<String, WeakShared<FlightFuture>>>,
     max_bytes: usize,
+    url_previews: UrlPreviews,
 }
 
 impl MediaService {
     pub(crate) fn new(client: Client, max_bytes: usize, max_sources: usize) -> Self {
         Self {
+            url_previews: UrlPreviews::new(client.clone()),
             client,
             registry: Mutex::new(MediaRegistry::new(max_sources)),
             flights: Mutex::new(HashMap::new()),
@@ -66,6 +68,10 @@ impl MediaService {
         }
     }
 
+    pub(crate) async fn url_preview(&self, url: &str) -> Result<Option<LinkPreview>, Error> {
+        self.url_previews.preview(url).await
+    }
+
     pub(crate) async fn register(&self, media: Vec<MediaRegistration>) {
         if !media.is_empty() {
             self.registry.lock().await.insert_all(media);

Modified file: src/engine/mod.rs+6 additions−2 deletions@@ -6,6 +6,7 @@ mod prepare;
 mod room;
 mod session;
 mod timeline;
+mod url_preview;
 mod watchers;
 
 use std::{
@@ -41,7 +42,7 @@ use crate::{
     AccountCommand, ClientHandle, Command, ConnectionState, EncryptionCommand, EngineErrorKind,
     EngineFailure, Error, ErrorKind, Event, EventStream, LifecycleCommand, MediaCommand,
     NotificationCommand, RoomCommand, Termination, TimelineCommand,
-    normalise::ROOM_PACKS,
+    normalise::{ROOM_PACKS, ROOM_PREVIEW_URLS},
     transport::{DriverPort, Request, Responder, transport_pair},
 };
 
@@ -310,7 +311,10 @@ impl Engine {
         let sync = Arc::new(
             SyncService::builder(client.clone())
                 .with_offline_mode()
-                .with_room_list_extra_required_state(vec![(ROOM_PACKS.into(), "*".to_owned())])
+                .with_room_list_extra_required_state(vec![
+                    (ROOM_PACKS.into(), "*".to_owned()),
+                    (ROOM_PREVIEW_URLS.into(), String::new()),
+                ])
                 .build()
                 .await
                 .map_err(EngineError::SyncService)?,

Added file: src/engine/url_preview.rs+166 additions@@ -0,0 +1,166 @@
+use std::{
+    collections::{HashMap, VecDeque},
+    sync::{
+        Arc,
+        atomic::{AtomicBool, Ordering},
+    },
+    time::Duration,
+};
+
+use futures_util::{FutureExt, future::WeakShared};
+use matrix_sdk::{
+    Client, HttpError,
+    ruma::api::{
+        Metadata,
+        client::{authenticated_media, media},
+    },
+};
+use ruma::{
+    api::error::ErrorKind as ApiErrorKind,
+    serde::{JsonObject, Raw},
+    time::Instant,
+};
+use tokio::sync::Mutex;
+
+use super::executor::EngineBoxFuture;
+use crate::{Error, LinkPreview, normalise::server_preview};
+
+const HIT_FOR: Duration = Duration::from_secs(60 * 60);
+const MISS_FOR: Duration = Duration::from_secs(10 * 60);
+const REMEMBERED: usize = 512;
+
+type Lookup = EngineBoxFuture<'static, Result<Option<LinkPreview>, Error>>;
+
+/// the homeserver rate limits `preview_url` and a busy timeline repeats links, so answers are
+/// kept a while, misses too, and asks for one url at once share one request
+pub(crate) struct UrlPreviews(Arc<Inner>);
+
+struct Inner {
+    client: Client,
+    /// a server that doesn't preview at all says so once and isn't asked again
+    unsupported: AtomicBool,
+    cache: Mutex<Cache>,
+    lookups: Mutex<HashMap<String, WeakShared<Lookup>>>,
+}
+
+#[derive(Default)]
+struct Cache {
+    entries: HashMap<String, (Instant, Option<LinkPreview>)>,
+    order: VecDeque<String>,
+}
+
+impl UrlPreviews {
+    pub(crate) fn new(client: Client) -> Self {
+        Self(Arc::new(Inner {
+            client,
+            unsupported: AtomicBool::new(false),
+            cache: Mutex::new(Cache::default()),
+            lookups: Mutex::new(HashMap::new()),
+        }))
+    }
+
+    pub(crate) async fn preview(&self, url: &str) -> Result<Option<LinkPreview>, Error> {
+        if self.0.unsupported.load(Ordering::Relaxed) {
+            return Ok(None);
+        }
+        if let Some(preview) = self.0.cache.lock().await.get(url) {
+            return Ok(preview);
+        }
+        let lookup = {
+            let mut lookups = self.0.lookups.lock().await;
+            lookups.retain(|_, lookup| lookup.upgrade().is_some());
+            match lookups.get(url).and_then(WeakShared::upgrade) {
+                Some(lookup) => lookup,
+                None => {
+                    let inner = self.0.clone();
+                    let owned = url.to_owned();
+                    let lookup: Lookup = Box::pin(async move { inner.look_up(owned).await });
+                    let lookup = lookup.shared();
+                    if let Some(weak) = lookup.downgrade() {
+                        lookups.insert(url.to_owned(), weak);
+                    }
+                    lookup
+                }
+            }
+        };
+        lookup.await
+    }
+}
+
+impl Inner {
+    async fn look_up(&self, url: String) -> Result<Option<LinkPreview>, Error> {
+        let data = match self.fetch(&url).await {
+            Ok(data) => data,
+            Err(error) => {
+                let Some(api) = error.as_client_api_error() else {
+                    return Err(Error::from_sdk(
+                        "asking for a url preview failed",
+                        error.into(),
+                    ));
+                };
+                let unrecognised = matches!(api.error_kind(), Some(ApiErrorKind::Unrecognized))
+                    || api.status_code.as_u16() == 405;
+                if unrecognised {
+                    self.unsupported.store(true, Ordering::Relaxed);
+                    return Ok(None);
+                }
+                // synapse answers 500 for a page it can't download, 502 when dns fails and 403 for
+                // its blocklist (synapse/media/url_previewer.py). a real fault hides in the 500s too,
+                // but a missing card is cheap and only cached ten minutes
+                if !matches!(api.status_code.as_u16(), 400 | 403 | 404 | 500 | 502) {
+                    return Err(Error::from_sdk(
+                        "asking for a url preview failed",
+                        error.into(),
+                    ));
+                }
+                None
+            }
+        };
+        let preview = data.and_then(|data| server_preview(&url, &data));
+        self.cache.lock().await.insert(url, preview.clone());
+        Ok(preview)
+    }
+
+    async fn fetch(&self, url: &str) -> Result<Option<Raw<JsonObject>>, HttpError> {
+        let versions = self.client.supported_versions().await?;
+        let data = if authenticated_media::get_media_preview::v1::Request::PATH_BUILDER
+            .is_supported(&versions)
+        {
+            self.client
+                .send(authenticated_media::get_media_preview::v1::Request::new(
+                    url.to_owned(),
+                ))
+                .await?
+                .data
+        } else {
+            #[allow(deprecated)]
+            let request = media::get_media_preview::v3::Request::new(url.to_owned());
+            self.client.send(request).await?.data
+        };
+        Ok(data.map(Raw::from_json))
+    }
+}
+
+impl Cache {
+    fn get(&mut self, url: &str) -> Option<Option<LinkPreview>> {
+        let (at, preview) = self.entries.get(url)?;
+        let lasts = if preview.is_some() { HIT_FOR } else { MISS_FOR };
+        (at.elapsed() < lasts).then(|| preview.clone())
+    }
+
+    fn insert(&mut self, url: String, preview: Option<LinkPreview>) {
+        if self
+            .entries
+            .insert(url.clone(), (Instant::now(), preview))
+            .is_none()
+        {
+            self.order.push_back(url);
+        }
+        while self.entries.len() > REMEMBERED {
+            let Some(oldest) = self.order.pop_front() else {
+                break;
+            };
+            self.entries.remove(&oldest);
+        }
+    }
+}

Modified file: src/error.rs+9 additions@@ -63,6 +63,8 @@ pub enum ErrorKind {
     NoCrossSigningIdentity,
     RecoveryRejected,
     Network,
+    /// the homeserver wants us to slow down. try again later
+    RateLimited,
     Server,
     Store,
     Timeline,
@@ -269,6 +271,13 @@ pub(crate) fn classify_sdk_error(source: &matrix_sdk::Error) -> ErrorKind {
 fn classify_http_error(source: &HttpError) -> ErrorKind {
     match source {
         HttpError::Reqwest(_) => ErrorKind::Network,
+        HttpError::Api(_)
+            if source
+                .as_client_api_error()
+                .is_some_and(|api| api.status_code.as_u16() == 429) =>
+        {
+            ErrorKind::RateLimited
+        }
         HttpError::Api(_) => ErrorKind::Server,
         HttpError::RefreshToken(source) => classify_refresh_token_error(source),
         HttpError::Cached(source) => classify_http_error(source),

Modified file: src/lib.rs+13 additions−12 deletions@@ -49,18 +49,19 @@ pub use model::{
     AccountCommand, AttachmentEncryption, AttachmentUpload, Change, Command, CommandOutput,
     ConnectionState, CreateRoomOptions, EncryptionCommand, EncryptionState, EngineErrorKind,
     EngineFailure, Event, EventRef, HistoryState, ImagePack, ImagePackSource, ImagePacks,
-    KeyBackupState, LatestEvent, LifecycleCommand, Media, MediaCommand, MediaDescriptor, MediaFile,
-    MediaId, MediaKind, MediaLocation, MediaSize, MemberFilter, MemberMembership, MemberSummary,
-    MembershipChange, Message, MessageContent, MessageEditContent, MessageKind, MessageMentions,
-    NotificationCommand, OwnDevice, PackImage, PackUsage, PowerLevelChanges, Profile,
-    PushNotification, PushNotificationEvent, PushNotificationRoom, PushNotificationSender,
-    PushNotificationStatus, Reaction, RecoveryState, ReplyDetails, ReplyReference, Retain,
-    RichText, RoomCategory, RoomCommand, RoomHero, RoomListFilter, RoomMatcher, RoomMembership,
-    RoomNotificationMode, RoomNotificationSettings, RoomPowerLevels, RoomPreset, RoomSummary,
-    RoomVisibility, SendState, Sender, SpaceChild, Termination, ThreadSummary, TimelineCommand,
-    TimelineContent, TimelineDiff, TimelineDiffError, TimelineEvent, TimelineId, TimelineItem,
-    TimelineItemId, TypingState, UploadDetails, UploadOutcome, UploadThumbnail, UtdCause,
-    VerificationAction, VerificationFailure, VerificationState, VerificationTarget,
+    KeyBackupState, LatestEvent, LifecycleCommand, LinkPreview, LinkPreviewImage, Media,
+    MediaCommand, MediaDescriptor, MediaFile, MediaId, MediaKind, MediaLocation, MediaSize,
+    MemberFilter, MemberMembership, MemberSummary, MembershipChange, Message, MessageContent,
+    MessageEditContent, MessageKind, MessageMentions, NotificationCommand, OwnDevice, PackImage,
+    PackUsage, PowerLevelChanges, Profile, PushNotification, PushNotificationEvent,
+    PushNotificationRoom, PushNotificationSender, PushNotificationStatus, Reaction, RecoveryState,
+    ReplyDetails, ReplyReference, Retain, RichText, RoomCategory, RoomCommand, RoomHero,
+    RoomListFilter, RoomMatcher, RoomMembership, RoomNotificationMode, RoomNotificationSettings,
+    RoomPowerLevels, RoomPreset, RoomSummary, RoomVisibility, SendState, Sender, SpaceChild,
+    Termination, ThreadSummary, TimelineCommand, TimelineContent, TimelineDiff, TimelineDiffError,
+    TimelineEvent, TimelineId, TimelineItem, TimelineItemId, TypingState, UploadDetails,
+    UploadOutcome, UploadThumbnail, UtdCause, VerificationAction, VerificationFailure,
+    VerificationState, VerificationTarget,
 };
 pub use ruma;
 pub use transport::{ClientHandle, EventStream, Pending, SpaceHierarchy};

Modified file: src/model.rs+30 additions@@ -1494,6 +1494,36 @@ pub struct Message {
     pub mentions: Option<MessageMentions>,
     pub edited: bool,
     pub media: Option<MediaDescriptor>,
+    /// previews the sender attached (msc4095), so showing them asks no one about the url.
+    /// one for a url the body doesn't contain is dropped
+    pub link_previews: Vec<LinkPreview>,
+}
+
+/// a link card, from the sender's own message or from `ClientHandle::url_preview`. page
+/// text passes through whoever made it unfiltered, so it arrives trimmed to a sane length
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
+pub struct LinkPreview {
+    /// the url as it appears in the message, or as it was asked about
+    pub url: String,
+    /// where the page says it lives, when that's somewhere else
+    pub canonical_url: Option<String>,
+    pub title: Option<String>,
+    pub description: Option<String>,
+    pub site_name: Option<String>,
+    pub image: Option<LinkPreviewImage>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
+pub struct LinkPreviewImage {
+    pub media_id: MediaId,
+    pub mimetype: Option<String>,
+    pub size_bytes: Option<u64>,
+    pub width: Option<u64>,
+    pub height: Option<u64>,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]

Added file: src/normalise/link_preview.rs+217 additions@@ -0,0 +1,217 @@
+use matrix_sdk::{Room, deserialized_responses::RawAnySyncOrStrippedState};
+use ruma::{
+    MxcUri,
+    events::{
+        GlobalAccountDataEventType, RoomAccountDataEventType, StateEventType,
+        room::{
+            MediaSource,
+            message::{MessageType, PreviewImageSource, UrlPreview},
+        },
+    },
+    serde::{JsonObject, Raw},
+};
+
+use super::media::{MediaRegistration, MediaSourceInfo, media_id};
+use crate::{Error, LinkPreview, LinkPreviewImage, MediaId, MediaKind};
+
+/// room state an admin sets, and room account data a user sets, under the same name
+pub(crate) const ROOM_PREVIEW_URLS: &str = "org.matrix.room.preview_urls";
+const USER_PREVIEW_URLS: &str = "org.matrix.preview_urls";
+
+const SHORT_TEXT: usize = 256;
+const LONG_TEXT: usize = 1024;
+
+/// the previews a text message's sender attached, each with the registration its image needs
+/// when it's encrypted. embedded reply content has no media identity, so its encrypted images
+/// go without
+pub(crate) fn sender_previews(
+    identity: Option<&str>,
+    message: &MessageType,
+) -> Vec<(LinkPreview, Option<MediaRegistration>)> {
+    let MessageType::Text(text) = message else {
+        return Vec::new();
+    };
+    text.url_previews
+        .iter()
+        .flatten()
+        .enumerate()
+        .filter_map(|(index, preview)| sender_preview(identity, &text.body, index, preview))
+        .collect()
+}
+
+/// the matched url has to be in the body, or a sender could caption any link with any card
+fn sender_preview(
+    identity: Option<&str>,
+    body: &str,
+    index: usize,
+    preview: &UrlPreview,
+) -> Option<(LinkPreview, Option<MediaRegistration>)> {
+    let url = preview.matched_url.as_deref()?;
+    if url.is_empty() || !body.contains(url) || !preview.contains_preview() {
+        return None;
+    }
+    let (image, registration) = match &preview.image {
+        None => (None, None),
+        Some(image) => {
+            let (media_id, registration) = match &image.source {
+                PreviewImageSource::Url(uri) => (plain(uri)?, None),
+                PreviewImageSource::EncryptedImage(file) => {
+                    let id = media_id(identity?, &format!("preview{index}"));
+                    let registration = MediaRegistration {
+                        id: id.clone(),
+                        kind: MediaKind::Image,
+                        full: MediaSourceInfo {
+                            source: MediaSource::Encrypted(Box::new(file.clone())),
+                            mimetype: image.mimetype.clone(),
+                            declared_size: image.size.map(u64::from),
+                        },
+                        thumbnail: None,
+                    };
+                    (id, Some(registration))
+                }
+            };
+            let image = LinkPreviewImage {
+                media_id,
+                mimetype: image.mimetype.clone(),
+                size_bytes: image.size.map(u64::from),
+                width: image.width.map(u64::from),
+                height: image.height.map(u64::from),
+            };
+            (Some(image), registration)
+        }
+    };
+    let preview = LinkPreview {
+        url: url.to_owned(),
+        canonical_url: preview.url.clone().filter(|canonical| canonical != url),
+        title: clamp(preview.title.as_deref(), SHORT_TEXT),
+        description: clamp(preview.description.as_deref(), LONG_TEXT),
+        site_name: None,
+        image,
+    };
+    Some((preview, registration))
+}
+
+/// what the homeserver's `preview_url` answered, a loose map of `og:` keys. `None` when
+/// nothing in it is worth a card
+pub(crate) fn server_preview(url: &str, data: &Raw<JsonObject>) -> Option<LinkPreview> {
+    let text = |key: &str| data.get_field::<String>(key).ok().flatten();
+    let image = text("og:image")
+        .as_deref()
+        .and_then(|uri| plain(<&MxcUri>::from(uri)))
+        .map(|media_id| LinkPreviewImage {
+            media_id,
+            mimetype: text("og:image:type"),
+            size_bytes: number(data, "matrix:image:size"),
+            width: number(data, "og:image:width"),
+            height: number(data, "og:image:height"),
+        });
+    let preview = LinkPreview {
+        url: url.to_owned(),
+        canonical_url: text("og:url").filter(|canonical| canonical != url),
+        title: clamp(text("og:title").as_deref(), SHORT_TEXT),
+        description: clamp(text("og:description").as_deref(), LONG_TEXT),
+        site_name: clamp(text("og:site_name").as_deref(), SHORT_TEXT),
+        image,
+    };
+    (preview.title.is_some() || preview.description.is_some() || preview.image.is_some())
+        .then_some(preview)
+}
+
+/// element's order, so both clients agree. the user's choice for this room, then their own
+/// default, then the room admins'. encrypted rooms are the host's call
+pub(crate) async fn url_previews_allowed(room: &Room) -> Result<bool, Error> {
+    let room_choice = room
+        .account_data(RoomAccountDataEventType::from(ROOM_PREVIEW_URLS))
+        .await
+        .map_err(|source| Error::from_sdk("reading url preview settings failed", source))?
+        .and_then(|event| disabled(&event.get_field::<Raw<JsonObject>>("content").ok()??));
+    let own_default = || async {
+        room.client()
+            .account()
+            .account_data_raw(GlobalAccountDataEventType::from(USER_PREVIEW_URLS))
+            .await
+            .map(|content| content.and_then(|content| disabled(&content.cast_unchecked())))
+            .map_err(|source| Error::from_sdk("reading url preview settings failed", source))
+    };
+    let admins = || async {
+        room.get_state_event(StateEventType::from(ROOM_PREVIEW_URLS), "")
+            .await
+            .map(|event| match event {
+                Some(RawAnySyncOrStrippedState::Sync(event)) => {
+                    disabled(&event.get_field::<Raw<JsonObject>>("content").ok()??)
+                }
+                _ => None,
+            })
+            .map_err(|source| Error::from_sdk("reading url preview settings failed", source))
+    };
+    let disabled = match room_choice {
+        Some(disabled) => disabled,
+        None => match own_default().await? {
+            Some(disabled) => disabled,
+            None => admins().await?.unwrap_or(false),
+        },
+    };
+    Ok(!disabled)
+}
+
+fn disabled(content: &Raw<JsonObject>) -> Option<bool> {
+    content.get_field::<bool>("disable").ok().flatten()
+}
+
+fn plain(uri: &MxcUri) -> Option<MediaId> {
+    uri.is_valid().then(|| MediaId::plain(uri))
+}
+
+/// servers send dimensions as numbers or as the page's own strings
+fn number(data: &Raw<JsonObject>, key: &str) -> Option<u64> {
+    data.get_field::<u64>(key).ok().flatten().or_else(|| {
+        data.get_field::<String>(key)
+            .ok()
+            .flatten()?
+            .trim()
+            .parse()
+            .ok()
+    })
+}
+
+fn clamp(text: Option<&str>, chars: usize) -> Option<String> {
+    let text = text?.trim();
+    (!text.is_empty()).then(|| match text.char_indices().nth(chars) {
+        Some((end, _)) => text[..end].trim_end().to_owned(),
+        None => text.to_owned(),
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use ruma::{events::room::message::MessageType, serde::Raw};
+    use serde_json::json;
+
+    use super::sender_previews;
+
+    #[test]
+    fn a_sender_cannot_caption_a_link_the_message_does_not_contain() {
+        let message: MessageType = Raw::new(&json!({
+            "msgtype": "m.text",
+            "body": "look at https://example.org/real",
+            "com.beeper.linkpreviews": [
+                {
+                    "matched_url": "https://example.org/real",
+                    "og:title": "real",
+                    "og:image": "mxc://example.org/image",
+                },
+                { "matched_url": "https://bank.example/login", "og:title": "your bank" },
+            ],
+        }))
+        .unwrap()
+        .cast_unchecked()
+        .deserialize()
+        .unwrap();
+        let previews = sender_previews(Some("1#item"), &message);
+        assert_eq!(previews.len(), 1);
+        let (preview, registration) = &previews[0];
+        assert_eq!(preview.url, "https://example.org/real");
+        assert_eq!(preview.title.as_deref(), Some("real"));
+        assert!(preview.image.is_some() && registration.is_none());
+    }
+}

Modified file: src/normalise/media.rs+20 additions−9 deletions@@ -10,6 +10,7 @@ use ruma::events::{
     sticker::StickerEventContent,
 };
 
+use super::link_preview::sender_previews;
 use crate::{MediaDescriptor, MediaId, MediaKind};
 
 static NEXT_MEDIA_SCOPE: AtomicU64 = AtomicU64::new(1);
@@ -54,20 +55,30 @@ pub(crate) struct MediaSourceInfo {
     pub(crate) declared_size: Option<u64>,
 }
 
-pub(super) fn media_registration_for_item(
+pub(super) fn media_registrations_for_item(
     item: &SdkTimelineItem,
     scope: &MediaScope,
-) -> Option<MediaRegistration> {
-    let event = item.as_event()?;
+) -> Vec<MediaRegistration> {
+    let Some(event) = item.as_event() else {
+        return Vec::new();
+    };
     let identity = media_identity(item, scope);
-    let content = match event.content() {
-        TimelineItemContent::MsgLike(content) => content,
-        _ => return None,
+    let TimelineItemContent::MsgLike(content) = event.content() else {
+        return Vec::new();
     };
     match &content.kind {
-        MsgLikeKind::Message(message) => media_registration(&identity, message.msgtype()),
-        MsgLikeKind::Sticker(sticker) => media_sticker_registration(&identity, sticker.content()),
-        _ => None,
+        MsgLikeKind::Message(message) => media_registration(&identity, message.msgtype())
+            .into_iter()
+            .chain(
+                sender_previews(Some(&identity), message.msgtype())
+                    .into_iter()
+                    .filter_map(|(_, registration)| registration),
+            )
+            .collect(),
+        MsgLikeKind::Sticker(sticker) => media_sticker_registration(&identity, sticker.content())
+            .into_iter()
+            .collect(),
+        _ => Vec::new(),
     }
 }
 

Modified file: src/normalise/mod.rs+2 additions@@ -1,10 +1,12 @@
 mod image_pack;
+mod link_preview;
 mod media;
 mod member;
 mod room;
 mod timeline;
 
 pub(crate) use image_pack::{ENABLED_ROOMS, ROOM_PACKS, USER_PACK, image_packs};
+pub(crate) use link_preview::{ROOM_PREVIEW_URLS, server_preview, url_previews_allowed};
 pub(crate) use media::{MediaRegistration, MediaScope, MediaSourceInfo};
 pub(crate) use member::member_summary;
 pub(crate) use room::notification_mode;

Modified file: src/normalise/timeline.rs+8 additions−4 deletions@@ -24,9 +24,10 @@ use crate::{
     TimelineEvent, TimelineItem, TimelineItemId, UtdCause,
 };
 
+use super::link_preview::sender_previews;
 use super::media::{
     MediaRegistration, MediaScope, media_descriptor_for_sticker, media_from_message,
-    media_identity, media_registration_for_item,
+    media_identity, media_registrations_for_item,
 };
 
 #[derive(Default)]
@@ -52,9 +53,8 @@ struct Normaliser<'a> {
 
 impl Normaliser<'_> {
     fn item(&mut self, item: &SdkTimelineItem) -> TimelineItem {
-        if let Some(media) = media_registration_for_item(item, self.scope) {
-            self.media.push(media);
-        }
+        self.media
+            .extend(media_registrations_for_item(item, self.scope));
         match item.kind() {
             TimelineItemKind::Event(event) => {
                 TimelineItem::Event(Box::new(self.event(item, event)))
@@ -282,6 +282,10 @@ fn msg_like(content: &MsgLikeContent, media_identity: Option<&str>) -> TimelineC
             edited: message.is_edited(),
             media: media_identity
                 .and_then(|identity| media_from_message(identity, message.msgtype())),
+            link_previews: sender_previews(media_identity, message.msgtype())
+                .into_iter()
+                .map(|(preview, _)| preview)
+                .collect(),
         }),
         MsgLikeKind::Sticker(sticker) => {
             let sticker = sticker.content();

Modified file: src/transport.rs+16 additions−5 deletions@@ -28,16 +28,16 @@ use tokio::sync::{OnceCell, mpsc, oneshot, watch};
 use crate::{
     AccountCommand, AttachmentUpload, Command, CommandOutput, ConnectionState, CreateRoomOptions,
     EncryptionCommand, EncryptionState, Error, ErrorKind, Event, EventRef, ImagePacks,
-    InteractiveAuth, InteractiveAuthOutcome, LifecycleCommand, Media, MediaCommand, MediaId,
-    MediaLocation, MediaSize, MemberFilter, MemberSummary, MessageContent, MessageEditContent,
-    NotificationCommand, OwnDevice, PowerLevelChanges, Profile, PushNotification,
-    PushNotificationEvent, PushNotificationStatus, RoomCommand, RoomListFilter,
+    InteractiveAuth, InteractiveAuthOutcome, LifecycleCommand, LinkPreview, Media, MediaCommand,
+    MediaId, MediaLocation, MediaSize, MemberFilter, MemberSummary, MessageContent,
+    MessageEditContent, NotificationCommand, OwnDevice, PowerLevelChanges, Profile,
+    PushNotification, PushNotificationEvent, PushNotificationStatus, RoomCommand, RoomListFilter,
     RoomNotificationMode, RoomNotificationSettings, RoomPowerLevels, RoomSummary, SpaceChild,
     TimelineCommand, TimelineId, VerificationAction, VerificationTarget,
     encryption::encryption_state,
     engine::{MediaService, StoreLock},
     model::{PushNotificationRoom, PushNotificationSender},
-    normalise::{image_packs, member_summary, room_summaries, space_child},
+    normalise::{image_packs, member_summary, room_summaries, space_child, url_previews_allowed},
 };
 
 #[derive(Clone)]
@@ -588,6 +588,17 @@ impl ClientHandle {
         image_packs(&self.client).await
     }
 
+    /// the homeserver's preview of a page, `None` when it has none. the homeserver sees every
+    /// url asked about, so a host decides whether encrypted rooms ask at all
+    pub async fn url_preview(&self, url: &str) -> Result<Option<LinkPreview>, Error> {
+        self.media.url_preview(url).await
+    }
+
+    /// whether the room and the user's settings let link previews show here
+    pub async fn url_previews_allowed(&self, room_id: &RoomId) -> Result<bool, Error> {
+        url_previews_allowed(&self.room(room_id)?).await
+    }
+
     /// browse a space the way the server sees it, rooms you haven't joined included
     pub async fn space_hierarchy(&self, space_id: OwnedRoomId) -> SpaceHierarchy {
         SpaceHierarchy(SpaceRoomList::new(self.client.clone(), space_id).await)

Modified file: tests/media.rs+78 additions@@ -992,3 +992,81 @@ fn plain_audio() -> RoomMessageEventContent {
         mxc_uri!("mxc://localhost/audio").to_owned(),
     )))
 }
+
+#[tokio::test]
+async fn url_previews_are_cached_and_say_why_they_failed() {
+    let mut harness = start(plain_image()).await;
+    let preview_url = || path_regex(r"/media(/v3)?/preview_url$");
+    let answer = |status: u16, body: Value| {
+        Mock::given(method("GET"))
+            .and(preview_url())
+            .and(wiremock::matchers::query_param(
+                "url",
+                "https://example.org/page",
+            ))
+            .respond_with(ResponseTemplate::new(status).set_body_json(body))
+    };
+    answer(
+        200,
+        json!({
+            "og:title": "  a page  ",
+            "og:image": "mxc://example.org/image",
+            "og:image:width": "640",
+            "og:description": "x".repeat(5000),
+        }),
+    )
+    .expect(1)
+    .mount(harness.server.server())
+    .await;
+
+    for _ in 0..2 {
+        let preview = harness
+            .handle
+            .url_preview("https://example.org/page")
+            .await
+            .unwrap()
+            .expect("a page with a title has a preview");
+        assert_eq!(preview.title.as_deref(), Some("a page"));
+        assert_eq!(
+            preview.description.map(|text| text.chars().count()),
+            Some(1024)
+        );
+        let image = preview.image.expect("an mxc og:image is kept");
+        assert_eq!(image.width, Some(640));
+    }
+
+    let failing = |status: u16, errcode: &str| {
+        Mock::given(method("GET"))
+            .and(preview_url())
+            .and(wiremock::matchers::query_param(
+                "url",
+                format!("https://example.org/{status}"),
+            ))
+            .respond_with(
+                ResponseTemplate::new(status)
+                    .set_body_json(json!({ "errcode": errcode, "error": "no" })),
+            )
+    };
+    failing(502, "M_UNKNOWN")
+        .mount(harness.server.server())
+        .await;
+    failing(429, "M_LIMIT_EXCEEDED")
+        .mount(harness.server.server())
+        .await;
+    assert_eq!(
+        harness
+            .handle
+            .url_preview("https://example.org/502")
+            .await
+            .unwrap(),
+        None
+    );
+    let limited = harness
+        .handle
+        .url_preview("https://example.org/429")
+        .await
+        .unwrap_err();
+    assert_eq!(limited.kind, ErrorKind::RateLimited);
+
+    support::shut_down(&harness.handle, &mut harness.events, harness.running).await;
+}

macltok

Commit 0291516d40b5

Commit `0291516d40b5`