feat: Allow authorization headers to be skipped with the RequestConfig

Author: poljar

crates/matrix-sdk/CHANGELOG.md

@@ -8,6 +8,9 @@ All notable changes to this project will be documented in this file.
 
 ### Features
 
+- Add a new `RequestConfig::skip_auth()` option. This is useful to ensure that
+  certain request won't ever include an authorization header.
+  ([#5822](https://github.com/matrix-org/matrix-rust-sdk/pull/5822))
 - Add support for extended profile fields with `Account::fetch_profile_field_of()`,
   `Account::fetch_profile_field_of_static()`, `Account::set_profile_field()` and
   `Account::delete_profile_field()`.

crates/matrix-sdk/src/client/mod.rs

@@ -1924,7 +1924,10 @@ impl Client {
     {
         let homeserver = self.homeserver().to_string();
         let access_token = self.access_token();
-        let path_builder_input = Request::PathBuilder::get_path_builder_input(self).await?;
+        let skip_auth = config.map(|c| c.skip_auth).unwrap_or(self.request_config().skip_auth);
+
+        let path_builder_input =
+            Request::PathBuilder::get_path_builder_input(self, skip_auth).await?;
 
         self.inner
             .http_client
@@ -2039,6 +2042,16 @@ impl Client {
         Ok(server_info)
     }
 
+    pub(crate) async fn get_cached_versions(&self) -> Option<SupportedVersions> {
+        let server_info = &self.inner.caches.server_info;
+
+        if let CachedValue::Cached(val) = &server_info.read().await.supported_versions {
+            Some(val.clone())
+        } else {
+            None
+        }
+    }
+
     async fn get_or_load_and_cache_server_info<
         Value,
         MapFunction: Fn(&ClientServerInfo) -> CachedValue<Value>,

crates/matrix-sdk/src/config/request.rs

@@ -48,6 +48,7 @@ pub struct RequestConfig {
     pub(crate) max_retry_time: Option<Duration>,
     pub(crate) max_concurrent_requests: Option<NonZeroUsize>,
     pub(crate) force_auth: bool,
+    pub(crate) skip_auth: bool,
 }
 
 #[cfg(not(tarpaulin_include))]
@@ -60,6 +61,7 @@ impl Debug for RequestConfig {
             max_retry_time: retry_timeout,
             force_auth,
             max_concurrent_requests,
+            skip_auth: skip_optional_auth,
         } = self;
 
         let mut res = fmt.debug_struct("RequestConfig");
@@ -73,6 +75,10 @@ impl Debug for RequestConfig {
             res.field("force_auth", &true);
         }
 
+        if *skip_optional_auth {
+            res.field("skip_optional_auth", &true);
+        }
+
         res.finish()
     }
 }
@@ -86,6 +92,7 @@ impl Default for RequestConfig {
             max_retry_time: Default::default(),
             max_concurrent_requests: Default::default(),
             force_auth: false,
+            skip_auth: false,
         }
     }
 }
@@ -168,6 +175,22 @@ impl RequestConfig {
         self.force_auth = true;
         self
     }
+
+    /// Skip sending authorization headers even if the endpoint requires it.
+    ///
+    /// Default is to send authorization headers if the endpoint accepts or
+    /// requires it.
+    ///
+    /// This is useful for endpoints that may optionally accept authorization
+    /// but don't require it.
+    ///
+    /// Note: [`RequestConfig::force_auth`] takes precedence. If force auth is
+    /// set, this value will be ignored.
+    #[must_use]
+    pub fn skip_auth(mut self) -> Self {
+        self.skip_auth = true;
+        self
+    }
 }
 
 #[cfg(test)]

crates/matrix-sdk/src/http_client/mod.rs

@@ -30,7 +30,7 @@ use eyeball::SharedObservable;
 use http::Method;
 use matrix_sdk_base::SendOutsideWasm;
 use ruma::api::{
-    OutgoingRequest,
+    OutgoingRequest, SupportedVersions,
     auth_scheme::{AuthScheme, SendAccessToken},
     error::{FromHttpResponseError, IntoHttpError},
     path_builder,
@@ -114,13 +114,11 @@ impl HttpClient {
         trace!(request_type = type_name::<R>(), "Serializing request");
 
         let send_access_token = match access_token {
-            Some(access_token) => {
-                if config.force_auth {
-                    SendAccessToken::Always(access_token)
-                } else {
-                    SendAccessToken::IfRequired(access_token)
-                }
-            }
+            Some(access_token) => match (config.force_auth, config.skip_auth) {
+                (true, true) | (true, false) => SendAccessToken::Always(access_token),
+                (false, true) => SendAccessToken::None,
+                (false, false) => SendAccessToken::IfRequired(access_token),
+            },
             None => SendAccessToken::None,
         };
 
@@ -256,19 +254,38 @@ async fn response_to_http_response(
 pub trait SupportedPathBuilder: path_builder::PathBuilder {
     fn get_path_builder_input(
         client: &crate::Client,
+        skip_auth: bool,
     ) -> impl Future<Output = HttpResult<Self::Input<'static>>> + SendOutsideWasm;
 }
 
 impl SupportedPathBuilder for path_builder::VersionHistory {
     async fn get_path_builder_input(
         client: &crate::Client,
-    ) -> HttpResult<Cow<'static, ruma::api::SupportedVersions>> {
-        client.supported_versions().await.map(Cow::Owned)
+        skip_auth: bool,
+    ) -> HttpResult<Cow<'static, SupportedVersions>> {
+        if skip_auth {
+            let cached_versions = client.get_cached_versions().await;
+
+            let versions = if let Some(versions) = cached_versions {
+                versions
+            } else {
+                // If we're skipping auth we might not get all the supported features, so just
+                // fetch the versions and don't cache them.
+                let request_config = RequestConfig::default().retry_limit(5).skip_auth();
+                let response = client.fetch_server_versions(Some(request_config)).await?;
+
+                response.as_supported_versions()
+            };
+
+            Ok(Cow::Owned(versions))
+        } else {
+            client.supported_versions().await.map(Cow::Owned)
+        }
     }
 }
 
 impl SupportedPathBuilder for path_builder::SinglePath {
-    async fn get_path_builder_input(_client: &crate::Client) -> HttpResult<()> {
+    async fn get_path_builder_input(_client: &crate::Client, _skip_auth: bool) -> HttpResult<()> {
         Ok(())
     }
 }