Move IMAP session state into imap::session::Session

IMAP capabilities and selected folder are IMAP session,
not IMAP client property.

Moving most operations into IMAP session structure
removes the need to constantly check whether IMAP session exists
and reduces number of invalid states, e.g. when a folder is selected but
there is no connection.

Capabilities are determined immediately after logging in,
so there is no need for `capabilities_determined` flag anymore.
Capabilities of the server are always known if there is a session.

`should_reconnect` flag and `disconnect()` function are removed: we
drop the session on error. Even though RFC 3501 says that a client
SHOULD NOT close the connection without a LOGOUT, it is more reliable
to always just drop the connection, especially after an error.

src/imap/capabilities.rs

@@ -0,0 +1,26 @@
+//! # IMAP capabilities
+//!
+//! IMAP server capabilities are determined with a `CAPABILITY` command.
+use std::collections::HashMap;
+
+#[derive(Debug)]
+pub(crate) struct Capabilities {
+    /// True if the server has IDLE capability as defined in
+    /// <https://tools.ietf.org/html/rfc2177>
+    pub can_idle: bool,
+
+    /// True if the server has MOVE capability as defined in
+    /// <https://tools.ietf.org/html/rfc6851>
+    pub can_move: bool,
+
+    /// True if the server has QUOTA capability as defined in
+    /// <https://tools.ietf.org/html/rfc2087>
+    pub can_check_quota: bool,
+
+    /// True if the server has CONDSTORE capability as defined in
+    /// <https://tools.ietf.org/html/rfc7162>
+    pub can_condstore: bool,
+
+    /// Server ID if the server supports ID capability.
+    pub server_id: Option<HashMap<String, String>>,
+}

src/imap/client.rs

@@ -6,10 +6,12 @@ use std::{
 use anyhow::{Context as _, Result};
 
 use async_imap::Client as ImapClient;
+use async_imap::Session as ImapSession;
 
 use async_smtp::ServerAddress;
 use tokio::net::{self, TcpStream};
 
+use super::capabilities::Capabilities;
 use super::session::Session;
 use crate::login_param::{build_tls, Socks5Config};
 
@@ -38,27 +40,54 @@ impl DerefMut for Client {
     }
 }
 
+/// Determine server capabilities.
+///
+/// If server supports ID capability, send our client ID.
+async fn determine_capabilities(
+    session: &mut ImapSession<Box<dyn SessionStream>>,
+) -> Result<Capabilities> {
+    let caps = session
+        .capabilities()
+        .await
+        .context("CAPABILITY command error")?;
+    let server_id = if caps.has_str("ID") {
+        session.id([("name", Some("Delta Chat"))]).await?
+    } else {
+        None
+    };
+    let capabilities = Capabilities {
+        can_idle: caps.has_str("IDLE"),
+        can_move: caps.has_str("MOVE"),
+        can_check_quota: caps.has_str("QUOTA"),
+        can_condstore: caps.has_str("CONDSTORE"),
+        server_id,
+    };
+    Ok(capabilities)
+}
+
 impl Client {
-    pub async fn login(self, username: &str, password: &str) -> Result<Session> {
+    pub(crate) async fn login(self, username: &str, password: &str) -> Result<Session> {
         let Client { inner, .. } = self;
-        let session = inner
+        let mut session = inner
             .login(username, password)
             .await
             .map_err(|(err, _client)| err)?;
-        Ok(Session { inner: session })
+        let capabilities = determine_capabilities(&mut session).await?;
+        Ok(Session::new(session, capabilities))
     }
 
-    pub async fn authenticate(
+    pub(crate) async fn authenticate(
         self,
         auth_type: &str,
         authenticator: impl async_imap::Authenticator,
     ) -> Result<Session> {
         let Client { inner, .. } = self;
-        let session = inner
+        let mut session = inner
             .authenticate(auth_type, authenticator)
             .await
             .map_err(|(err, _client)| err)?;
-        Ok(Session { inner: session })
+        let capabilities = determine_capabilities(&mut session).await?;
+        Ok(Session::new(session, capabilities))
     }
 
     pub async fn connect_secure(
@@ -146,7 +175,7 @@ impl Client {
         })
     }
 
-    pub async fn secure(self, domain: &str, strict_tls: bool) -> Result<Client> {
+    pub async fn secure(self, domain: &str, strict_tls: bool) -> Result<Self> {
         if self.is_secure {
             Ok(self)
         } else {

src/imap/idle.rs

@@ -1,113 +1,106 @@
 use super::Imap;
 
 use anyhow::{bail, Context as _, Result};
+use async_channel::Receiver;
 use async_imap::extensions::idle::IdleResponse;
 use futures_lite::FutureExt;
 use std::time::{Duration, SystemTime};
 
+use super::session::Session;
 use crate::{context::Context, scheduler::InterruptInfo};
 
-use super::session::Session;
-
-impl Imap {
-    pub fn can_idle(&self) -> bool {
-        self.config.can_idle
-    }
-
+impl Session {
     pub async fn idle(
-        &mut self,
+        mut self,
         context: &Context,
+        idle_interrupt_receiver: Receiver<InterruptInfo>,
         watch_folder: Option<String>,
-    ) -> Result<InterruptInfo> {
+    ) -> Result<(Self, InterruptInfo)> {
         use futures::future::FutureExt;
 
         if !self.can_idle() {
             bail!("IMAP server does not have IDLE capability");
         }
-        self.prepare(context).await?;
-
-        self.select_folder(context, watch_folder.as_deref()).await?;
 
         let timeout = Duration::from_secs(23 * 60);
         let mut info = Default::default();
 
+        self.select_folder(context, watch_folder.as_deref()).await?;
+
         if self.server_sent_unsolicited_exists(context)? {
-            return Ok(info);
+            return Ok((self, info));
         }
 
-        if let Some(session) = self.session.take() {
-            if let Ok(info) = self.idle_interrupt.try_recv() {
-                info!(context, "skip idle, got interrupt {:?}", info);
-                self.session = Some(session);
-                return Ok(info);
-            }
-
-            let mut handle = session.idle();
-            if let Err(err) = handle.init().await {
-                bail!("IMAP IDLE protocol failed to init/complete: {}", err);
-            }
-
-            let (idle_wait, interrupt) = handle.wait_with_timeout(timeout);
-
-            enum Event {
-                IdleResponse(IdleResponse),
-                Interrupt(InterruptInfo),
-            }
-
-            let folder_name = watch_folder.as_deref().unwrap_or("None");
-            info!(
-                context,
-                "{}: Idle entering wait-on-remote state", folder_name
-            );
-            let fut = idle_wait.map(|ev| ev.map(Event::IdleResponse)).race(async {
-                let info = self.idle_interrupt.recv().await;
-
-                // cancel imap idle connection properly
-                drop(interrupt);
-
-                Ok(Event::Interrupt(info.unwrap_or_default()))
-            });
-
-            match fut.await {
-                Ok(Event::IdleResponse(IdleResponse::NewData(x))) => {
-                    info!(context, "{}: Idle has NewData {:?}", folder_name, x);
-                }
-                Ok(Event::IdleResponse(IdleResponse::Timeout)) => {
-                    info!(
-                        context,
-                        "{}: Idle-wait timeout or interruption", folder_name
-                    );
-                }
-                Ok(Event::IdleResponse(IdleResponse::ManualInterrupt)) => {
-                    info!(
-                        context,
-                        "{}: Idle wait was interrupted manually", folder_name
-                    );
-                }
-                Ok(Event::Interrupt(i)) => {
-                    info!(
-                        context,
-                        "{}: Idle wait was interrupted: {:?}", folder_name, &i
-                    );
-                    info = i;
-                }
-                Err(err) => {
-                    warn!(context, "{}: Idle wait errored: {:?}", folder_name, err);
-                }
-            }
-
-            let session = tokio::time::timeout(Duration::from_secs(15), handle.done())
-                .await
-                .with_context(|| format!("{}: IMAP IDLE protocol timed out", folder_name))?
-                .with_context(|| format!("{}: IMAP IDLE failed", folder_name))?;
-            self.session = Some(Session { inner: session });
-        } else {
-            warn!(context, "Attempted to idle without a session");
+        if let Ok(info) = idle_interrupt_receiver.try_recv() {
+            info!(context, "skip idle, got interrupt {:?}", info);
+            return Ok((self, info));
         }
 
-        Ok(info)
+        let mut handle = self.inner.idle();
+        if let Err(err) = handle.init().await {
+            bail!("IMAP IDLE protocol failed to init/complete: {}", err);
+        }
+
+        let (idle_wait, interrupt) = handle.wait_with_timeout(timeout);
+
+        enum Event {
+            IdleResponse(IdleResponse),
+            Interrupt(InterruptInfo),
+        }
+
+        let folder_name = watch_folder.as_deref().unwrap_or("None");
+        info!(
+            context,
+            "{}: Idle entering wait-on-remote state", folder_name
+        );
+        let fut = idle_wait.map(|ev| ev.map(Event::IdleResponse)).race(async {
+            let info = idle_interrupt_receiver.recv().await;
+
+            // cancel imap idle connection properly
+            drop(interrupt);
+
+            Ok(Event::Interrupt(info.unwrap_or_default()))
+        });
+
+        match fut.await {
+            Ok(Event::IdleResponse(IdleResponse::NewData(x))) => {
+                info!(context, "{}: Idle has NewData {:?}", folder_name, x);
+            }
+            Ok(Event::IdleResponse(IdleResponse::Timeout)) => {
+                info!(
+                    context,
+                    "{}: Idle-wait timeout or interruption", folder_name
+                );
+            }
+            Ok(Event::IdleResponse(IdleResponse::ManualInterrupt)) => {
+                info!(
+                    context,
+                    "{}: Idle wait was interrupted manually", folder_name
+                );
+            }
+            Ok(Event::Interrupt(i)) => {
+                info!(
+                    context,
+                    "{}: Idle wait was interrupted: {:?}", folder_name, &i
+                );
+                info = i;
+            }
+            Err(err) => {
+                warn!(context, "{}: Idle wait errored: {:?}", folder_name, err);
+            }
+        }
+
+        let session = tokio::time::timeout(Duration::from_secs(15), handle.done())
+            .await
+            .with_context(|| format!("{}: IMAP IDLE protocol timed out", folder_name))?
+            .with_context(|| format!("{}: IMAP IDLE failed", folder_name))?;
+        self.inner = session;
+
+        Ok((self, info))
     }
+}
 
+impl Imap {
     pub(crate) async fn fake_idle(
         &mut self,
         context: &Context,
@@ -123,7 +116,11 @@ impl Imap {
             watch_folder
         } else {
             info!(context, "IMAP-fake-IDLE: no folder, waiting for interrupt");
-            return self.idle_interrupt.recv().await.unwrap_or_default();
+            return self
+                .idle_interrupt_receiver
+                .recv()
+                .await
+                .unwrap_or_default();
         };
         info!(context, "IMAP-fake-IDLEing folder={:?}", watch_folder);
 
@@ -142,7 +139,7 @@ impl Imap {
                 .tick()
                 .map(|_| Event::Tick)
                 .race(
-                    self.idle_interrupt
+                    self.idle_interrupt_receiver
                         .recv()
                         .map(|probe_network| Event::Interrupt(probe_network.unwrap_or_default())),
                 )
@@ -156,9 +153,11 @@ impl Imap {
                         warn!(context, "fake_idle: could not connect: {}", err);
                         continue;
                     }
-                    if self.config.can_idle {
-                        // we only fake-idled because network was gone during IDLE, probably
-                        break InterruptInfo::new(false);
+                    if let Some(session) = &self.session {
+                        if session.can_idle() {
+                            // we only fake-idled because network was gone during IDLE, probably
+                            break InterruptInfo::new(false);
+                        }
                     }
                     info!(context, "fake_idle is connected");
                     // we are connected, let's see if fetching messages results
@@ -177,7 +176,7 @@ impl Imap {
                         }
                         Err(err) => {
                             error!(context, "could not fetch from folder: {:#}", err);
-                            self.trigger_reconnect(context).await;
+                            self.trigger_reconnect(context);
                         }
                     }
                 }

src/imap/scan_folders.rs

@@ -63,16 +63,18 @@ impl Imap {
 
             // Don't scan folders that are watched anyway
             if !watched_folders.contains(&folder.name().to_string()) && !is_drafts {
+                let session = self.session.as_mut().context("no session")?;
                 // Drain leftover unsolicited EXISTS messages
-                self.server_sent_unsolicited_exists(context)?;
+                session.server_sent_unsolicited_exists(context)?;
 
                 loop {
                     self.fetch_move_delete(context, folder.name(), is_spam_folder)
                         .await
                         .ok_or_log_msg(context, "Can't fetch new msgs in scanned folder");
 
+                    let session = self.session.as_mut().context("no session")?;
                     // If the server sent an unsocicited EXISTS during the fetch, we need to fetch again
-                    if !self.server_sent_unsolicited_exists(context)? {
+                    if !session.server_sent_unsolicited_exists(context)? {
                         break;
                     }
                 }

src/imap/select_folder.rs

@@ -1,4 +1,4 @@
-use super::Imap;
+use super::session::Session as ImapSession;
 
 use crate::context::Context;
 use anyhow::Context as _;
@@ -7,9 +7,6 @@ type Result<T> = std::result::Result<T, Error>;
 
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
-    #[error("IMAP Could not obtain imap-session object.")]
-    NoSession,
-
     #[error("IMAP Connection Lost or no connection established")]
     ConnectionLost,
 
@@ -29,55 +26,38 @@ impl From<anyhow::Error> for Error {
     }
 }
 
-impl Imap {
-    /// Issues a CLOSE command to expunge selected folder.
+impl ImapSession {
+    /// Issues a CLOSE command if selected folder needs expunge,
+    /// i.e. if Delta Chat marked a message there as deleted previously.
     ///
     /// CLOSE is considerably faster than an EXPUNGE, see
     /// <https://tools.ietf.org/html/rfc3501#section-6.4.2>
-    pub(super) async fn close_folder(&mut self, context: &Context) -> anyhow::Result<()> {
-        if let Some(ref folder) = self.config.selected_folder {
-            info!(context, "Expunge messages in \"{}\".", folder);
+    pub(super) async fn maybe_close_folder(&mut self, context: &Context) -> anyhow::Result<()> {
+        if let Some(folder) = &self.selected_folder {
+            if self.selected_folder_needs_expunge {
+                info!(context, "Expunge messages in \"{}\".", folder);
 
-            let session = self.session.as_mut().context("no session")?;
-            if let Err(err) = session.close().await.context("IMAP close/expunge failed") {
-                self.trigger_reconnect(context).await;
-                return Err(err);
+                self.close().await.context("IMAP close/expunge failed")?;
+                info!(context, "close/expunge succeeded");
+                self.selected_folder = None;
+                self.selected_folder_needs_expunge = false;
             }
-            info!(context, "close/expunge succeeded");
-        }
-        self.config.selected_folder = None;
-        self.config.selected_folder_needs_expunge = false;
-
-        Ok(())
-    }
-
-    /// Issues a CLOSE command if selected folder needs expunge.
-    pub(crate) async fn maybe_close_folder(&mut self, context: &Context) -> anyhow::Result<()> {
-        if self.config.selected_folder_needs_expunge {
-            self.close_folder(context).await?;
         }
         Ok(())
     }
 
-    /// select a folder, possibly update uid_validity and, if needed,
-    /// expunge the folder to remove delete-marked messages.
+    /// Selects a folder, possibly updating uid_validity and, if needed,
+    /// expunging the folder to remove delete-marked messages.
     /// Returns whether a new folder was selected.
     pub(super) async fn select_folder(
         &mut self,
         context: &Context,
         folder: Option<&str>,
     ) -> Result<NewlySelected> {
-        if self.session.is_none() {
-            self.config.selected_folder = None;
-            self.config.selected_folder_needs_expunge = false;
-            self.trigger_reconnect(context).await;
-            return Err(Error::NoSession);
-        }
-
         // if there is a new folder and the new folder is equal to the selected one, there's nothing to do.
         // if there is _no_ new folder, we continue as we might want to expunge below.
         if let Some(folder) = folder {
-            if let Some(ref selected_folder) = self.config.selected_folder {
+            if let Some(selected_folder) = &self.selected_folder {
                 if folder == selected_folder {
                     return Ok(NewlySelected::No);
                 }
@@ -89,42 +69,30 @@ impl Imap {
 
         // select new folder
         if let Some(folder) = folder {
-            if let Some(ref mut session) = &mut self.session {
-                let res = if self.config.can_condstore {
-                    session.select_condstore(folder).await
-                } else {
-                    session.select(folder).await
-                };
-
-                // <https://tools.ietf.org/html/rfc3501#section-6.3.1>
-                // says that if the server reports select failure we are in
-                // authenticated (not-select) state.
-
-                match res {
-                    Ok(mailbox) => {
-                        self.config.selected_folder = Some(folder.to_string());
-                        self.config.selected_mailbox = Some(mailbox);
-                        Ok(NewlySelected::Yes)
-                    }
-                    Err(async_imap::error::Error::ConnectionLost) => {
-                        self.trigger_reconnect(context).await;
-                        self.config.selected_folder = None;
-                        Err(Error::ConnectionLost)
-                    }
-                    Err(async_imap::error::Error::Validate(_)) => {
-                        Err(Error::BadFolderName(folder.to_string()))
-                    }
-                    Err(async_imap::error::Error::No(response)) => {
-                        Err(Error::NoFolder(folder.to_string(), response))
-                    }
-                    Err(err) => {
-                        self.config.selected_folder = None;
-                        self.trigger_reconnect(context).await;
-                        Err(Error::Other(err.to_string()))
-                    }
-                }
+            let res = if self.can_condstore() {
+                self.select_condstore(folder).await
             } else {
-                Err(Error::NoSession)
+                self.select(folder).await
+            };
+
+            // <https://tools.ietf.org/html/rfc3501#section-6.3.1>
+            // says that if the server reports select failure we are in
+            // authenticated (not-select) state.
+
+            match res {
+                Ok(mailbox) => {
+                    self.selected_folder = Some(folder.to_string());
+                    self.selected_mailbox = Some(mailbox);
+                    Ok(NewlySelected::Yes)
+                }
+                Err(async_imap::error::Error::ConnectionLost) => Err(Error::ConnectionLost),
+                Err(async_imap::error::Error::Validate(_)) => {
+                    Err(Error::BadFolderName(folder.to_string()))
+                }
+                Err(async_imap::error::Error::No(response)) => {
+                    Err(Error::NoFolder(folder.to_string(), response))
+                }
+                Err(err) => Err(Error::Other(err.to_string())),
             }
         } else {
             Ok(NewlySelected::No)
@@ -141,8 +109,7 @@ impl Imap {
             Ok(newly_selected) => Ok(newly_selected),
             Err(err) => match err {
                 Error::NoFolder(..) => {
-                    let session = self.session.as_mut().context("no IMAP session")?;
-                    session.create(folder).await.with_context(|| {
+                    self.create(folder).await.with_context(|| {
                         format!("Couldn't select folder ('{}'), then create() failed", err)
                     })?;
 
@@ -153,6 +120,7 @@ impl Imap {
         }
     }
 }
+
 #[derive(PartialEq, Debug, Copy, Clone, Eq)]
 pub(super) enum NewlySelected {
     /// The folder was newly selected during this call to select_folder().

src/imap/session.rs

@@ -1,13 +1,26 @@
 use std::ops::{Deref, DerefMut};
 
+use async_imap::types::Mailbox;
 use async_imap::Session as ImapSession;
 use async_native_tls::TlsStream;
 use fast_socks5::client::Socks5Stream;
 use tokio::net::TcpStream;
 
+use super::capabilities::Capabilities;
+
 #[derive(Debug)]
 pub(crate) struct Session {
     pub(super) inner: ImapSession<Box<dyn SessionStream>>,
+
+    pub capabilities: Capabilities,
+
+    /// Selected folder name.
+    pub selected_folder: Option<String>,
+
+    /// Mailbox structure returned by IMAP server.
+    pub selected_mailbox: Option<Mailbox>,
+
+    pub selected_folder_needs_expunge: bool,
 }
 
 pub(crate) trait SessionStream:
@@ -35,8 +48,32 @@ impl DerefMut for Session {
 }
 
 impl Session {
-    pub fn idle(self) -> async_imap::extensions::idle::Handle<Box<dyn SessionStream>> {
-        let Session { inner } = self;
-        inner.idle()
+    pub(crate) fn new(
+        inner: ImapSession<Box<dyn SessionStream>>,
+        capabilities: Capabilities,
+    ) -> Self {
+        Self {
+            inner,
+            capabilities,
+            selected_folder: None,
+            selected_mailbox: None,
+            selected_folder_needs_expunge: false,
+        }
+    }
+
+    pub fn can_idle(&self) -> bool {
+        self.capabilities.can_idle
+    }
+
+    pub fn can_move(&self) -> bool {
+        self.capabilities.can_move
+    }
+
+    pub fn can_check_quota(&self) -> bool {
+        self.capabilities.can_check_quota
+    }
+
+    pub fn can_condstore(&self) -> bool {
+        self.capabilities.can_condstore
     }
 }