fix: Use fallback ICE servers if server can't IMAP METADATA (#7382)

src/imap.rs

@@ -123,7 +123,7 @@ struct OAuth2 {
     access_token: String,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub(crate) struct ServerMetadata {
     /// IMAP METADATA `/shared/comment` as defined in
     /// <https://www.rfc-editor.org/rfc/rfc5464#section-6.2.1>.
@@ -1546,17 +1546,17 @@ impl Session {
         Ok(())
     }
 
-    /// Retrieves server metadata if it is supported.
+    /// Retrieves server metadata if it is supported, otherwise uses fallback one.
     ///
     /// We get [`/shared/comment`](https://www.rfc-editor.org/rfc/rfc5464#section-6.2.1)
     /// and [`/shared/admin`](https://www.rfc-editor.org/rfc/rfc5464#section-6.2.2)
     /// metadata.
-    pub(crate) async fn fetch_metadata(&mut self, context: &Context) -> Result<()> {
+    pub(crate) async fn update_metadata(&mut self, context: &Context) -> Result<()> {
-        if !self.can_metadata() {
-            return Ok(());
-        }
-
         let mut lock = context.metadata.write().await;
+
+        if !self.can_metadata() {
+            *lock = Some(Default::default());
+        }
         if let Some(ref mut old_metadata) = *lock {
             let now = time();
 
@@ -1565,31 +1565,33 @@ impl Session {
                 return Ok(());
             }
 
-            info!(context, "ICE servers expired, requesting new credentials.");
-            let mailbox = "";
-            let options = "";
-            let metadata = self
-                .get_metadata(mailbox, options, "(/shared/vendor/deltachat/turn)")
-                .await?;
             let mut got_turn_server = false;
-            for m in metadata {
+            if self.can_metadata() {
-                if m.entry == "/shared/vendor/deltachat/turn"
+                info!(context, "ICE servers expired, requesting new credentials.");
-                    && let Some(value) = m.value
+                let mailbox = "";
-                {
+                let options = "";
-                    match create_ice_servers_from_metadata(context, &value).await {
+                let metadata = self
-                        Ok((parsed_timestamp, parsed_ice_servers)) => {
+                    .get_metadata(mailbox, options, "(/shared/vendor/deltachat/turn)")
-                            old_metadata.ice_servers_expiration_timestamp = parsed_timestamp;
+                    .await?;
-                            old_metadata.ice_servers = parsed_ice_servers;
+                for m in metadata {
-                            got_turn_server = true;
+                    if m.entry == "/shared/vendor/deltachat/turn"
-                        }
+                        && let Some(value) = m.value
-                        Err(err) => {
+                    {
-                            warn!(context, "Failed to parse TURN server metadata: {err:#}.");
+                        match create_ice_servers_from_metadata(context, &value).await {
+                            Ok((parsed_timestamp, parsed_ice_servers)) => {
+                                old_metadata.ice_servers_expiration_timestamp = parsed_timestamp;
+                                old_metadata.ice_servers = parsed_ice_servers;
+                                got_turn_server = true;
+                            }
+                            Err(err) => {
+                                warn!(context, "Failed to parse TURN server metadata: {err:#}.");
+                            }
                         }
                     }
                 }
             }
-
             if !got_turn_server {
+                info!(context, "Will use fallback ICE servers.");
                 // Set expiration timestamp 7 days in the future so we don't request it again.
                 old_metadata.ice_servers_expiration_timestamp = time() + 3600 * 24 * 7;
                 old_metadata.ice_servers = create_fallback_ice_servers(context).await?;

src/scheduler.rs

@@ -538,9 +538,9 @@ async fn inbox_fetch_idle(ctx: &Context, imap: &mut Imap, mut session: Session)
         .await
         .context("Failed to download messages")?;
     session
-        .fetch_metadata(ctx)
+        .update_metadata(ctx)
         .await
-        .context("Failed to fetch metadata")?;
+        .context("update_metadata")?;
     session
         .register_token(ctx)
         .await