Merge pull request 'Implement imap-flow' (#34) from refactor/imap-flow into main

Reviewed-on: https://git.deuxfleurs.fr/Deuxfleurs/aerogramme/pulls/34

1 files changed, 127 insertions, 34 deletions

diff --git a/src/imap/command/selected.rs b/src/imap/command/selected.rs
index 90a00ee..220a952 100644
--- a/src/imap/command/selected.rs
+++ b/src/imap/command/selected.rs
@@ -1,31 +1,50 @@
 use std::sync::Arc;
 
 use anyhow::Result;
-use boitalettres::proto::Request;
-use boitalettres::proto::Response;
-use imap_codec::types::command::CommandBody;
-use imap_codec::types::flag::{Flag, StoreResponse, StoreType};
-use imap_codec::types::mailbox::Mailbox as MailboxCodec;
-use imap_codec::types::response::Code;
-use imap_codec::types::sequence::SequenceSet;
-
-use crate::imap::command::examined;
+use imap_codec::imap_types::command::{Command, CommandBody};
+use imap_codec::imap_types::core::Charset;
+use imap_codec::imap_types::fetch::MacroOrMessageDataItemNames;
+use imap_codec::imap_types::flag::{Flag, StoreResponse, StoreType};
+use imap_codec::imap_types::mailbox::Mailbox as MailboxCodec;
+use imap_codec::imap_types::response::{Code, CodeOther};
+use imap_codec::imap_types::search::SearchKey;
+use imap_codec::imap_types::sequence::SequenceSet;
+
+use crate::imap::command::{anystate, authenticated, MailboxName};
 use crate::imap::flow;
 use crate::imap::mailbox_view::MailboxView;
+use crate::imap::response::Response;
 
 use crate::mail::user::User;
 
 pub struct SelectedContext<'a> {
-    pub req: &'a Request,
+    pub req: &'a Command<'static>,
     pub user: &'a Arc<User>,
     pub mailbox: &'a mut MailboxView,
 }
 
-pub async fn dispatch(ctx: SelectedContext<'_>) -> Result<(Response, flow::Transition)> {
-    match &ctx.req.command.body {
-        // Only write commands here, read commands are handled in
-        // `examined.rs`
+pub async fn dispatch<'a>(
+    ctx: SelectedContext<'a>,
+) -> Result<(Response<'static>, flow::Transition)> {
+    match &ctx.req.body {
+        // Any State
+        // noop is specific to this state
+        CommandBody::Capability => anystate::capability(ctx.req.tag.clone()),
+        CommandBody::Logout => anystate::logout(),
+
+        // Specific to this state (7 commands + NOOP)
         CommandBody::Close => ctx.close().await,
+        CommandBody::Noop | CommandBody::Check => ctx.noop().await,
+        CommandBody::Fetch {
+            sequence_set,
+            macro_or_item_names,
+            uid,
+        } => ctx.fetch(sequence_set, macro_or_item_names, uid).await,
+        CommandBody::Search {
+            charset,
+            criteria,
+            uid,
+        } => ctx.search(charset, criteria, uid).await,
         CommandBody::Expunge => ctx.expunge().await,
         CommandBody::Store {
             sequence_set,
@@ -39,13 +58,14 @@ pub async fn dispatch(ctx: SelectedContext<'_>) -> Result<(Response, flow::Trans
             mailbox,
             uid,
         } => ctx.copy(sequence_set, mailbox, uid).await,
+
+        // In selected mode, we fallback to authenticated when needed
         _ => {
-            let ctx = examined::ExaminedContext {
+            authenticated::dispatch(authenticated::AuthenticatedContext {
                 req: ctx.req,
                 user: ctx.user,
-                mailbox: ctx.mailbox,
-            };
-            examined::dispatch(ctx).await
+            })
+            .await
         }
     }
 }
@@ -53,18 +73,81 @@ pub async fn dispatch(ctx: SelectedContext<'_>) -> Result<(Response, flow::Trans
 // --- PRIVATE ---
 
 impl<'a> SelectedContext<'a> {
-    async fn close(self) -> Result<(Response, flow::Transition)> {
+    async fn close(self) -> Result<(Response<'static>, flow::Transition)> {
         // We expunge messages,
         // but we don't send the untagged EXPUNGE responses
+        let tag = self.req.tag.clone();
         self.expunge().await?;
-        Ok((Response::ok("CLOSE completed")?, flow::Transition::Unselect))
+        Ok((
+            Response::build().tag(tag).message("CLOSE completed").ok()?,
+            flow::Transition::Unselect,
+        ))
+    }
+
+    pub async fn fetch(
+        self,
+        sequence_set: &SequenceSet,
+        attributes: &'a MacroOrMessageDataItemNames<'static>,
+        uid: &bool,
+    ) -> Result<(Response<'static>, flow::Transition)> {
+        match self.mailbox.fetch(sequence_set, attributes, uid).await {
+            Ok(resp) => Ok((
+                Response::build()
+                    .to_req(self.req)
+                    .message("FETCH completed")
+                    .set_body(resp)
+                    .ok()?,
+                flow::Transition::None,
+            )),
+            Err(e) => Ok((
+                Response::build()
+                    .to_req(self.req)
+                    .message(e.to_string())
+                    .no()?,
+                flow::Transition::None,
+            )),
+        }
+    }
+
+    pub async fn search(
+        self,
+        _charset: &Option<Charset<'a>>,
+        _criteria: &SearchKey<'a>,
+        _uid: &bool,
+    ) -> Result<(Response<'static>, flow::Transition)> {
+        Ok((
+            Response::build()
+                .to_req(self.req)
+                .message("Not implemented")
+                .bad()?,
+            flow::Transition::None,
+        ))
     }
 
-    async fn expunge(self) -> Result<(Response, flow::Transition)> {
+    pub async fn noop(self) -> Result<(Response<'static>, flow::Transition)> {
+        self.mailbox.mailbox.force_sync().await?;
+
+        let updates = self.mailbox.update().await?;
+        Ok((
+            Response::build()
+                .to_req(self.req)
+                .message("NOOP completed.")
+                .set_body(updates)
+                .ok()?,
+            flow::Transition::None,
+        ))
+    }
+
+    async fn expunge(self) -> Result<(Response<'static>, flow::Transition)> {
+        let tag = self.req.tag.clone();
         let data = self.mailbox.expunge().await?;
 
         Ok((
-            Response::ok("EXPUNGE completed")?.with_body(data),
+            Response::build()
+                .tag(tag)
+                .message("EXPUNGE completed")
+                .set_body(data)
+                .ok()?,
             flow::Transition::None,
         ))
     }
@@ -74,16 +157,20 @@ impl<'a> SelectedContext<'a> {
         sequence_set: &SequenceSet,
         kind: &StoreType,
         response: &StoreResponse,
-        flags: &[Flag],
+        flags: &[Flag<'a>],
         uid: &bool,
-    ) -> Result<(Response, flow::Transition)> {
+    ) -> Result<(Response<'static>, flow::Transition)> {
         let data = self
             .mailbox
             .store(sequence_set, kind, response, flags, uid)
             .await?;
 
         Ok((
-            Response::ok("STORE completed")?.with_body(data),
+            Response::build()
+                .to_req(self.req)
+                .message("STORE completed")
+                .set_body(data)
+                .ok()?,
             flow::Transition::None,
         ))
     }
@@ -91,18 +178,21 @@ impl<'a> SelectedContext<'a> {
     async fn copy(
         self,
         sequence_set: &SequenceSet,
-        mailbox: &MailboxCodec,
+        mailbox: &MailboxCodec<'a>,
         uid: &bool,
-    ) -> Result<(Response, flow::Transition)> {
-        let name = String::try_from(mailbox.clone())?;
+    ) -> Result<(Response<'static>, flow::Transition)> {
+        let name: &str = MailboxName(mailbox).try_into()?;
 
         let mb_opt = self.user.open_mailbox(&name).await?;
         let mb = match mb_opt {
             Some(mb) => mb,
             None => {
                 return Ok((
-                    Response::no("Destination mailbox does not exist")?
-                        .with_extra_code(Code::TryCreate),
+                    Response::build()
+                        .to_req(self.req)
+                        .message("Destination mailbox does not exist")
+                        .code(Code::TryCreate)
+                        .no()?,
                     flow::Transition::None,
                 ))
             }
@@ -126,10 +216,13 @@ impl<'a> SelectedContext<'a> {
         );
 
         Ok((
-            Response::ok("COPY completed")?.with_extra_code(Code::Other(
-                "COPYUID".try_into().unwrap(),
-                Some(copyuid_str),
-            )),
+            Response::build()
+                .to_req(self.req)
+                .message("COPY completed")
+                .code(Code::Other(CodeOther::unvalidated(
+                    format!("COPYUID {}", copyuid_str).into_bytes(),
+                )))
+                .ok()?,
             flow::Transition::None,
         ))
     }