Cargo.lock

@@ -1723,7 +1723,7 @@ dependencies = [
  "httpdate",
  "itoa",
  "pin-project-lite 0.2.13",
- "socket2 0.5.5",
+ "socket2 0.4.10",
  "tokio",
  "tower-service",
  "tracing",

Cargo.toml

@@ -58,7 +58,7 @@ aws-sdk-s3 = "1.9.0"
 eml-codec = { git = "https://git.deuxfleurs.fr/Deuxfleurs/eml-codec.git", branch = "main" }
 smtp-message = { git = "http://github.com/Alexis211/kannader", branch = "feature/lmtp" }
 smtp-server = { git = "http://github.com/Alexis211/kannader", branch = "feature/lmtp" }
-imap-codec = { version = "1.0.0", features = ["quirk_crlf_relaxed", "bounded-static", "ext_condstore_qresync"] }
+imap-codec = { version = "1.0.0", features = ["bounded-static", "ext_condstore_qresync"] }
 imap-flow = { git = "https://github.com/duesee/imap-flow.git", rev = "e45ce7bb6ab6bda3c71a0c7b05e9b558a5902e90" }
 
 [dev-dependencies]

src/imap/attributes.rs

@@ -0,0 +1,49 @@
+use imap_codec::imap_types::fetch::{MacroOrMessageDataItemNames, MessageDataItemName};
+
+/// Internal decisions based on fetched attributes
+/// passed by the client
+
+pub struct AttributesProxy {
+    pub attrs: Vec<MessageDataItemName<'static>>,
+}
+impl AttributesProxy {
+    pub fn new(attrs: &MacroOrMessageDataItemNames<'static>, is_uid_fetch: bool) -> Self {
+        // Expand macros
+        let mut fetch_attrs = match attrs {
+            MacroOrMessageDataItemNames::Macro(m) => {
+                use imap_codec::imap_types::fetch::Macro;
+                use MessageDataItemName::*;
+                match m {
+                    Macro::All => vec![Flags, InternalDate, Rfc822Size, Envelope],
+                    Macro::Fast => vec![Flags, InternalDate, Rfc822Size],
+                    Macro::Full => vec![Flags, InternalDate, Rfc822Size, Envelope, Body],
+                    _ => {
+                        tracing::error!("unimplemented macro");
+                        vec![]
+                    }
+                }
+            }
+            MacroOrMessageDataItemNames::MessageDataItemNames(a) => a.clone(),
+        };
+
+        // Handle uids
+        if is_uid_fetch && !fetch_attrs.contains(&MessageDataItemName::Uid) {
+            fetch_attrs.push(MessageDataItemName::Uid);
+        }
+
+        Self { attrs: fetch_attrs }
+    }
+
+    pub fn need_body(&self) -> bool {
+        self.attrs.iter().any(|x| {
+            matches!(
+                x,
+                MessageDataItemName::Body
+                    | MessageDataItemName::BodyExt { .. }
+                    | MessageDataItemName::Rfc822
+                    | MessageDataItemName::Rfc822Text
+                    | MessageDataItemName::BodyStructure
+            )
+        })
+    }
+}

src/imap/command/examined.rs

@@ -125,7 +125,7 @@ impl<'a> ExaminedContext<'a> {
     }
 
     pub async fn noop(self) -> Result<(Response<'static>, flow::Transition)> {
-        self.mailbox.mailbox.force_sync().await?;
+        self.mailbox.0.mailbox.force_sync().await?;
 
         let updates = self.mailbox.update().await?;
         Ok((

src/imap/command/selected.rs

@@ -136,21 +136,23 @@ impl<'a> SelectedContext<'a> {
 
     pub async fn search(
         self,
-        _charset: &Option<Charset<'a>>,
-        _criteria: &SearchKey<'a>,
-        _uid: &bool,
+        charset: &Option<Charset<'a>>,
+        criteria: &SearchKey<'a>,
+        uid: &bool,
     ) -> Result<(Response<'static>, flow::Transition)> {
+        let found = self.mailbox.search(charset, criteria, *uid).await?;
         Ok((
             Response::build()
                 .to_req(self.req)
-                .message("Not implemented")
-                .bad()?,
+                .set_body(found)
+                .message("SEARCH completed")
+                .ok()?,
             flow::Transition::None,
         ))
     }
 
     pub async fn noop(self) -> Result<(Response<'static>, flow::Transition)> {
-        self.mailbox.mailbox.force_sync().await?;
+        self.mailbox.0.mailbox.force_sync().await?;
 
         let updates = self.mailbox.update().await?;
         Ok((

src/imap/flags.rs

@@ -0,0 +1,30 @@
+use imap_codec::imap_types::core::Atom;
+use imap_codec::imap_types::flag::{Flag, FlagFetch};
+
+pub fn from_str(f: &str) -> Option<FlagFetch<'static>> {
+    match f.chars().next() {
+        Some('\\') => match f {
+            "\\Seen" => Some(FlagFetch::Flag(Flag::Seen)),
+            "\\Answered" => Some(FlagFetch::Flag(Flag::Answered)),
+            "\\Flagged" => Some(FlagFetch::Flag(Flag::Flagged)),
+            "\\Deleted" => Some(FlagFetch::Flag(Flag::Deleted)),
+            "\\Draft" => Some(FlagFetch::Flag(Flag::Draft)),
+            "\\Recent" => Some(FlagFetch::Recent),
+            _ => match Atom::try_from(f.strip_prefix('\\').unwrap().to_string()) {
+                Err(_) => {
+                    tracing::error!(flag=%f, "Unable to encode flag as IMAP atom");
+                    None
+                }
+                Ok(a) => Some(FlagFetch::Flag(Flag::system(a))),
+            },
+        },
+        Some(_) => match Atom::try_from(f.to_string()) {
+            Err(_) => {
+                tracing::error!(flag=%f, "Unable to encode flag as IMAP atom");
+                None
+            }
+            Ok(a) => Some(FlagFetch::Flag(Flag::keyword(a))),
+        },
+        None => None,
+    }
+}

src/imap/imf_view.rs

@@ -0,0 +1,97 @@
+use imap_codec::imap_types::core::{IString, NString};
+use imap_codec::imap_types::envelope::{Address, Envelope};
+
+use eml_codec::imf;
+
+/// Envelope rules are defined in RFC 3501, section 7.4.2
+/// https://datatracker.ietf.org/doc/html/rfc3501#section-7.4.2
+///
+/// Some important notes:
+///
+/// If the Sender or Reply-To lines are absent in the [RFC-2822]
+/// header, or are present but empty, the server sets the
+/// corresponding member of the envelope to be the same value as
+/// the from member (the client is not expected to know to do
+/// this). Note: [RFC-2822] requires that all messages have a valid
+/// From header.  Therefore, the from, sender, and reply-to
+/// members in the envelope can not be NIL.
+///
+/// If the Date, Subject, In-Reply-To, and Message-ID header lines
+/// are absent in the [RFC-2822] header, the corresponding member
+/// of the envelope is NIL; if these header lines are present but
+/// empty the corresponding member of the envelope is the empty
+/// string.
+
+//@FIXME return an error if the envelope is invalid instead of panicking
+//@FIXME some fields must be defaulted if there are not set.
+pub fn message_envelope(msg: &imf::Imf) -> Envelope<'static> {
+    let from = msg.from.iter().map(convert_mbx).collect::<Vec<_>>();
+
+    Envelope {
+        date: NString(
+            msg.date
+                .as_ref()
+                .map(|d| IString::try_from(d.to_rfc3339()).unwrap()),
+        ),
+        subject: NString(
+            msg.subject
+                .as_ref()
+                .map(|d| IString::try_from(d.to_string()).unwrap()),
+        ),
+        sender: msg
+            .sender
+            .as_ref()
+            .map(|v| vec![convert_mbx(v)])
+            .unwrap_or(from.clone()),
+        reply_to: if msg.reply_to.is_empty() {
+            from.clone()
+        } else {
+            convert_addresses(&msg.reply_to)
+        },
+        from,
+        to: convert_addresses(&msg.to),
+        cc: convert_addresses(&msg.cc),
+        bcc: convert_addresses(&msg.bcc),
+        in_reply_to: NString(
+            msg.in_reply_to
+                .iter()
+                .next()
+                .map(|d| IString::try_from(d.to_string()).unwrap()),
+        ),
+        message_id: NString(
+            msg.msg_id
+                .as_ref()
+                .map(|d| IString::try_from(d.to_string()).unwrap()),
+        ),
+    }
+}
+
+pub fn convert_addresses(addrlist: &Vec<imf::address::AddressRef>) -> Vec<Address<'static>> {
+    let mut acc = vec![];
+    for item in addrlist {
+        match item {
+            imf::address::AddressRef::Single(a) => acc.push(convert_mbx(a)),
+            imf::address::AddressRef::Many(l) => acc.extend(l.participants.iter().map(convert_mbx)),
+        }
+    }
+    return acc;
+}
+
+pub fn convert_mbx(addr: &imf::mailbox::MailboxRef) -> Address<'static> {
+    Address {
+        name: NString(
+            addr.name
+                .as_ref()
+                .map(|x| IString::try_from(x.to_string()).unwrap()),
+        ),
+        // SMTP at-domain-list (source route) seems obsolete since at least 1991
+        // https://www.mhonarc.org/archive/html/ietf-822/1991-06/msg00060.html
+        adl: NString(None),
+        mailbox: NString(Some(
+            IString::try_from(addr.addrspec.local_part.to_string()).unwrap(),
+        )),
+        host: NString(Some(
+            IString::try_from(addr.addrspec.domain.to_string()).unwrap(),
+        )),
+    }
+}

src/imap/index.rs

@@ -0,0 +1,95 @@
+use std::num::NonZeroU32;
+
+use anyhow::{anyhow, bail, Result};
+use imap_codec::imap_types::sequence::{self, SequenceSet};
+
+use crate::mail::uidindex::{ImapUid, UidIndex};
+use crate::mail::unique_ident::UniqueIdent;
+
+pub struct Index<'a>(pub &'a UidIndex);
+impl<'a> Index<'a> {
+    pub fn fetch(
+        self: &Index<'a>,
+        sequence_set: &SequenceSet,
+        by_uid: bool,
+    ) -> Result<Vec<MailIndex<'a>>> {
+        let mail_vec = self
+            .0
+            .idx_by_uid
+            .iter()
+            .map(|(uid, uuid)| (*uid, *uuid))
+            .collect::<Vec<_>>();
+
+        let mut mails = vec![];
+
+        if by_uid {
+            if mail_vec.is_empty() {
+                return Ok(vec![]);
+            }
+            let iter_strat = sequence::Strategy::Naive {
+                largest: mail_vec.last().unwrap().0,
+            };
+
+            let mut i = 0;
+            for uid in sequence_set.iter(iter_strat) {
+                while mail_vec.get(i).map(|mail| mail.0 < uid).unwrap_or(false) {
+                    i += 1;
+                }
+                if let Some(mail) = mail_vec.get(i) {
+                    if mail.0 == uid {
+                        mails.push(MailIndex {
+                            i: NonZeroU32::try_from(i as u32 + 1).unwrap(),
+                            uid: mail.0,
+                            uuid: mail.1,
+                            flags: self
+                                .0
+                                .table
+                                .get(&mail.1)
+                                .ok_or(anyhow!("mail is missing from index"))?
+                                .1
+                                .as_ref(),
+                        });
+                    }
+                } else {
+                    break;
+                }
+            }
+        } else {
+            if mail_vec.is_empty() {
+                bail!("No such message (mailbox is empty)");
+            }
+
+            let iter_strat = sequence::Strategy::Naive {
+                largest: NonZeroU32::try_from((mail_vec.len()) as u32).unwrap(),
+            };
+
+            for i in sequence_set.iter(iter_strat) {
+                if let Some(mail) = mail_vec.get(i.get() as usize - 1) {
+                    mails.push(MailIndex {
+                        i,
+                        uid: mail.0,
+                        uuid: mail.1,
+                        flags: self
+                            .0
+                            .table
+                            .get(&mail.1)
+                            .ok_or(anyhow!("mail is missing from index"))?
+                            .1
+                            .as_ref(),
+                    });
+                } else {
+                    bail!("No such mail: {}", i);
+                }
+            }
+        }
+
+        Ok(mails)
+    }
+}
+
+pub struct MailIndex<'a> {
+    pub i: NonZeroU32,
+    pub uid: ImapUid,
+    pub uuid: UniqueIdent,
+    pub flags: &'a Vec<String>,
+}

src/imap/mail_view.rs

@@ -0,0 +1,247 @@
+use std::num::NonZeroU32;
+
+use anyhow::{anyhow, bail, Result};
+use chrono::{Offset, TimeZone, Utc};
+
+use imap_codec::imap_types::core::NString;
+use imap_codec::imap_types::datetime::DateTime;
+use imap_codec::imap_types::fetch::{
+    MessageDataItem, MessageDataItemName, Section as FetchSection,
+};
+use imap_codec::imap_types::flag::Flag;
+use imap_codec::imap_types::response::Data;
+
+use eml_codec::{
+    imf,
+    part::{composite::Message, AnyPart},
+};
+
+use crate::mail::query::QueryResult;
+
+use crate::imap::attributes::AttributesProxy;
+use crate::imap::flags;
+use crate::imap::imf_view::message_envelope;
+use crate::imap::index::MailIndex;
+use crate::imap::mime_view;
+use crate::imap::response::Body;
+
+pub struct MailView<'a> {
+    pub in_idx: MailIndex<'a>,
+    pub query_result: &'a QueryResult<'a>,
+    pub content: FetchedMail<'a>,
+}
+
+impl<'a> MailView<'a> {
+    pub fn new(query_result: &'a QueryResult<'a>, in_idx: MailIndex<'a>) -> Result<MailView<'a>> {
+        Ok(Self {
+            in_idx,
+            query_result,
+            content: match query_result {
+                QueryResult::FullResult { content, .. } => {
+                    let (_, parsed) =
+                        eml_codec::parse_message(&content).or(Err(anyhow!("Invalid mail body")))?;
+                    FetchedMail::new_from_message(parsed)
+                }
+                QueryResult::PartialResult { metadata, .. } => {
+                    let (_, parsed) = eml_codec::parse_imf(&metadata.headers)
+                        .or(Err(anyhow!("unable to parse email headers")))?;
+                    FetchedMail::Partial(parsed)
+                }
+                QueryResult::IndexResult { .. } => FetchedMail::IndexOnly,
+            },
+        })
+    }
+
+    fn uid(&self) -> MessageDataItem<'static> {
+        MessageDataItem::Uid(self.in_idx.uid.clone())
+    }
+
+    fn flags(&self) -> MessageDataItem<'static> {
+        MessageDataItem::Flags(
+            self.in_idx
+                .flags
+                .iter()
+                .filter_map(|f| flags::from_str(f))
+                .collect(),
+        )
+    }
+
+    fn rfc_822_size(&self) -> Result<MessageDataItem<'static>> {
+        let sz = self
+            .query_result
+            .metadata()
+            .ok_or(anyhow!("mail metadata are required"))?
+            .rfc822_size;
+        Ok(MessageDataItem::Rfc822Size(sz as u32))
+    }
+
+    fn rfc_822_header(&self) -> Result<MessageDataItem<'static>> {
+        let hdrs: NString = self
+            .query_result
+            .metadata()
+            .ok_or(anyhow!("mail metadata are required"))?
+            .headers
+            .to_vec()
+            .try_into()?;
+        Ok(MessageDataItem::Rfc822Header(hdrs))
+    }
+
+    fn rfc_822_text(&self) -> Result<MessageDataItem<'static>> {
+        let txt: NString = self.content.as_full()?.raw_body.to_vec().try_into()?;
+        Ok(MessageDataItem::Rfc822Text(txt))
+    }
+
+    fn rfc822(&self) -> Result<MessageDataItem<'static>> {
+        let full: NString = self.content.as_full()?.raw_part.to_vec().try_into()?;
+        Ok(MessageDataItem::Rfc822(full))
+    }
+
+    fn envelope(&self) -> MessageDataItem<'static> {
+        MessageDataItem::Envelope(message_envelope(self.content.imf().clone()))
+    }
+
+    fn body(&self) -> Result<MessageDataItem<'static>> {
+        Ok(MessageDataItem::Body(mime_view::bodystructure(
+            self.content.as_full()?.child.as_ref(),
+        )?))
+    }
+
+    fn body_structure(&self) -> Result<MessageDataItem<'static>> {
+        Ok(MessageDataItem::Body(mime_view::bodystructure(
+            self.content.as_full()?.child.as_ref(),
+        )?))
+    }
+
+    /// maps to BODY[<section>]<<partial>> and BODY.PEEK[<section>]<<partial>>
+    /// peek does not implicitly set the \Seen flag
+    /// eg. BODY[HEADER.FIELDS (DATE FROM)]
+    /// eg. BODY[]<0.2048>
+    fn body_ext(
+        &self,
+        section: &Option<FetchSection<'static>>,
+        partial: &Option<(u32, NonZeroU32)>,
+        peek: &bool,
+    ) -> Result<(MessageDataItem<'static>, SeenFlag)> {
+        // Manage Seen flag
+        let mut seen = SeenFlag::DoNothing;
+        let seen_flag = Flag::Seen.to_string();
+        if !peek && !self.in_idx.flags.iter().any(|x| *x == seen_flag) {
+            // Add \Seen flag
+            //self.mailbox.add_flags(uuid, &[seen_flag]).await?;
+            seen = SeenFlag::MustAdd;
+        }
+
+        // Process message
+        let (text, origin) =
+            match mime_view::body_ext(self.content.as_anypart()?, section, partial)? {
+                mime_view::BodySection::Full(body) => (body, None),
+                mime_view::BodySection::Slice { body, origin_octet } => (body, Some(origin_octet)),
+            };
+
+        let data: NString = text.to_vec().try_into()?;
+
+        return Ok((
+            MessageDataItem::BodyExt {
+                section: section.as_ref().map(|fs| fs.clone()),
+                origin,
+                data,
+            },
+            seen,
+        ));
+    }
+
+    fn internal_date(&self) -> Result<MessageDataItem<'static>> {
+        let dt = Utc
+            .fix()
+            .timestamp_opt(
+                i64::try_from(
+                    self.query_result
+                        .metadata()
+                        .ok_or(anyhow!("mail metadata were not fetched"))?
+                        .internaldate
+                        / 1000,
+                )?,
+                0,
+            )
+            .earliest()
+            .ok_or(anyhow!("Unable to parse internal date"))?;
+        Ok(MessageDataItem::InternalDate(DateTime::unvalidated(dt)))
+    }
+
+    pub fn filter(&self, ap: &AttributesProxy) -> Result<(Body<'static>, SeenFlag)> {
+        let mut seen = SeenFlag::DoNothing;
+        let res_attrs = ap
+            .attrs
+            .iter()
+            .map(|attr| match attr {
+                MessageDataItemName::Uid => Ok(self.uid()),
+                MessageDataItemName::Flags => Ok(self.flags()),
+                MessageDataItemName::Rfc822Size => self.rfc_822_size(),
+                MessageDataItemName::Rfc822Header => self.rfc_822_header(),
+                MessageDataItemName::Rfc822Text => self.rfc_822_text(),
+                MessageDataItemName::Rfc822 => self.rfc822(),
+                MessageDataItemName::Envelope => Ok(self.envelope()),
+                MessageDataItemName::Body => self.body(),
+                MessageDataItemName::BodyStructure => self.body_structure(),
+                MessageDataItemName::BodyExt {
+                    section,
+                    partial,
+                    peek,
+                } => {
+                    let (body, has_seen) = self.body_ext(section, partial, peek)?;
+                    seen = has_seen;
+                    Ok(body)
+                }
+                MessageDataItemName::InternalDate => self.internal_date(),
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((
+            Body::Data(Data::Fetch {
+                seq: self.in_idx.i,
+                items: res_attrs.try_into()?,
+            }),
+            seen,
+        ))
+    }
+}
+
+pub enum SeenFlag {
+    DoNothing,
+    MustAdd,
+}
+
+// -------------------
+
+pub enum FetchedMail<'a> {
+    IndexOnly,
+    Partial(imf::Imf<'a>),
+    Full(AnyPart<'a>),
+}
+impl<'a> FetchedMail<'a> {
+    pub fn new_from_message(msg: Message<'a>) -> Self {
+        Self::Full(AnyPart::Msg(msg))
+    }
+
+    fn as_anypart(&self) -> Result<&AnyPart<'a>> {
+        match self {
+            FetchedMail::Full(x) => Ok(&x),
+            _ => bail!("The full message must be fetched, not only its headers"),
+        }
+    }
+
+    fn as_full(&self) -> Result<&Message<'a>> {
+        match self {
+            FetchedMail::Full(AnyPart::Msg(x)) => Ok(&x),
+            _ => bail!("The full message must be fetched, not only its headers AND it must be an AnyPart::Msg."),
+        }
+    }
+
+    fn imf(&self) -> &imf::Imf<'a> {
+        match self {
+            FetchedMail::Full(AnyPart::Msg(x)) => &x.imf,
+            FetchedMail::Partial(x) => &x,
+            _ => panic!("Can't contain AnyPart that is not a message"),
+        }
+    }
+}

src/imap/mime_view.rs

@@ -0,0 +1,538 @@
+use std::borrow::Cow;
+use std::collections::HashSet;
+use std::num::NonZeroU32;
+
+use anyhow::{anyhow, bail, Result};
+
+use imap_codec::imap_types::body::{BasicFields, Body as FetchBody, BodyStructure, SpecificFields};
+use imap_codec::imap_types::core::{AString, IString, NString, NonEmptyVec};
+use imap_codec::imap_types::fetch::{Part as FetchPart, Section as FetchSection};
+
+use eml_codec::{
+    header, mime, mime::r#type::Deductible, part::composite, part::discrete, part::AnyPart,
+};
+
+use crate::imap::imf_view::message_envelope;
+
+pub enum BodySection<'a> {
+    Full(Cow<'a, [u8]>),
+    Slice {
+        body: Cow<'a, [u8]>,
+        origin_octet: u32,
+    },
+}
+
+/// Logic for BODY[<section>]<<partial>>
+/// Works in 3 times:
+///  1. Find the section (RootMime::subset)
+///  2. Apply the extraction logic (SelectedMime::extract), like TEXT, HEADERS, etc.
+///  3. Keep only the given subset provided by partial
+///
+/// Example of message sections:
+///
+/// ```
+///    HEADER     ([RFC-2822] header of the message)
+///    TEXT       ([RFC-2822] text body of the message) MULTIPART/MIXED
+///    1          TEXT/PLAIN
+///    2          APPLICATION/OCTET-STREAM
+///    3          MESSAGE/RFC822
+///    3.HEADER   ([RFC-2822] header of the message)
+///    3.TEXT     ([RFC-2822] text body of the message) MULTIPART/MIXED
+///    3.1        TEXT/PLAIN
+///    3.2        APPLICATION/OCTET-STREAM
+///    4          MULTIPART/MIXED
+///    4.1        IMAGE/GIF
+///    4.1.MIME   ([MIME-IMB] header for the IMAGE/GIF)
+///    4.2        MESSAGE/RFC822
+///    4.2.HEADER ([RFC-2822] header of the message)
+///    4.2.TEXT   ([RFC-2822] text body of the message) MULTIPART/MIXED
+///    4.2.1      TEXT/PLAIN
+///    4.2.2      MULTIPART/ALTERNATIVE
+///    4.2.2.1    TEXT/PLAIN
+///    4.2.2.2    TEXT/RICHTEXT
+/// ```
+pub fn body_ext<'a>(
+    part: &'a AnyPart<'a>,
+    section: &'a Option<FetchSection<'a>>,
+    partial: &'a Option<(u32, NonZeroU32)>,
+) -> Result<BodySection<'a>> {
+    let root_mime = NodeMime(part);
+    let (extractor, path) = SubsettedSection::from(section);
+    let selected_mime = root_mime.subset(path)?;
+    let extracted_full = selected_mime.extract(&extractor)?;
+    Ok(extracted_full.to_body_section(partial))
+}
+
+/// Logic for BODY and BODYSTRUCTURE
+///
+/// ```raw
+/// b fetch 29878:29879 (BODY)
+/// * 29878 FETCH (BODY (("text" "plain" ("charset" "utf-8") NIL NIL "quoted-printable" 3264 82)("text" "html" ("charset" "utf-8") NIL NIL "quoted-printable" 31834 643) "alternative"))
+/// * 29879 FETCH (BODY ("text" "html" ("charset" "us-ascii") NIL NIL "7bit" 4107 131))
+///                                   ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^^^^^^ ^^^^ ^^^
+///                                   |                      |   |   |      |    | number of lines
+///                                   |                      |   |   |      | size
+///                                   |                      |   |   | content transfer encoding
+///                                   |                      |   | description
+///                                   |                      | id
+///                                   | parameter list
+/// b OK Fetch completed (0.001 + 0.000 secs).
+/// ```
+pub fn bodystructure(part: &AnyPart) -> Result<BodyStructure<'static>> {
+    NodeMime(part).structure()
+}
+
+/// NodeMime
+///
+/// Used for recursive logic on MIME.
+/// See SelectedMime for inspection.
+struct NodeMime<'a>(&'a AnyPart<'a>);
+impl<'a> NodeMime<'a> {
+    /// A MIME object is a tree of elements.
+    /// The path indicates which element must be picked.
+    /// This function returns the picked element as the new view
+    fn subset(self, path: Option<&'a FetchPart>) -> Result<SelectedMime<'a>> {
+        match path {
+            None => Ok(SelectedMime(self.0)),
+            Some(v) => self.rec_subset(v.0.as_ref()),
+        }
+    }
+
+    fn rec_subset(self, path: &'a [NonZeroU32]) -> Result<SelectedMime> {
+        if path.is_empty() {
+            Ok(SelectedMime(self.0))
+        } else {
+            match self.0 {
+                AnyPart::Mult(x) => {
+                    let next = Self(x.children
+                        .get(path[0].get() as usize - 1)
+                        .ok_or(anyhow!("Unable to resolve subpath {:?}, current multipart has only {} elements", path, x.children.len()))?);
+                    next.rec_subset(&path[1..])
+                },
+                AnyPart::Msg(x) => {
+                    let next = Self(x.child.as_ref());
+                    next.rec_subset(path)
+                },
+                _ => bail!("You tried to access a subpart on an atomic part (text or binary). Unresolved subpath {:?}", path),
+            }
+        }
+    }
+
+    fn structure(&self) -> Result<BodyStructure<'static>> {
+        match self.0 {
+            AnyPart::Txt(x) => NodeTxt(self, x).structure(),
+            AnyPart::Bin(x) => NodeBin(self, x).structure(),
+            AnyPart::Mult(x) => NodeMult(self, x).structure(),
+            AnyPart::Msg(x) => NodeMsg(self, x).structure(),
+        }
+    }
+}
+
+//----------------------------------------------------------
+
+/// A FetchSection must be handled in 2 times:
+///  - First we must extract the MIME part
+///  - Then we must process it as desired
+/// The given struct mixes both work, so
+/// we separate this work here.
+enum SubsettedSection<'a> {
+    Part,
+    Header,
+    HeaderFields(&'a NonEmptyVec<AString<'a>>),
+    HeaderFieldsNot(&'a NonEmptyVec<AString<'a>>),
+    Text,
+    Mime,
+}
+impl<'a> SubsettedSection<'a> {
+    fn from(section: &'a Option<FetchSection>) -> (Self, Option<&'a FetchPart>) {
+        match section {
+            Some(FetchSection::Text(maybe_part)) => (Self::Text, maybe_part.as_ref()),
+            Some(FetchSection::Header(maybe_part)) => (Self::Header, maybe_part.as_ref()),
+            Some(FetchSection::HeaderFields(maybe_part, fields)) => {
+                (Self::HeaderFields(fields), maybe_part.as_ref())
+            }
+            Some(FetchSection::HeaderFieldsNot(maybe_part, fields)) => {
+                (Self::HeaderFieldsNot(fields), maybe_part.as_ref())
+            }
+            Some(FetchSection::Mime(part)) => (Self::Mime, Some(part)),
+            Some(FetchSection::Part(part)) => (Self::Part, Some(part)),
+            None => (Self::Part, None),
+        }
+    }
+}
+
+/// Used for current MIME inspection
+///
+/// See NodeMime for recursive logic
+struct SelectedMime<'a>(&'a AnyPart<'a>);
+impl<'a> SelectedMime<'a> {
+    /// The subsetted fetch section basically tells us the
+    /// extraction logic to apply on our selected MIME.
+    /// This function acts as a router for these logic.
+    fn extract(&self, extractor: &SubsettedSection<'a>) -> Result<ExtractedFull<'a>> {
+        match extractor {
+            SubsettedSection::Text => self.text(),
+            SubsettedSection::Header => self.header(),
+            SubsettedSection::HeaderFields(fields) => self.header_fields(fields, false),
+            SubsettedSection::HeaderFieldsNot(fields) => self.header_fields(fields, true),
+            SubsettedSection::Part => self.part(),
+            SubsettedSection::Mime => self.mime(),
+        }
+    }
+
+    fn mime(&self) -> Result<ExtractedFull<'a>> {
+        let bytes = match &self.0 {
+            AnyPart::Txt(p) => p.mime.fields.raw,
+            AnyPart::Bin(p) => p.mime.fields.raw,
+            AnyPart::Msg(p) => p.child.mime().raw,
+            AnyPart::Mult(p) => p.mime.fields.raw,
+        };
+        Ok(ExtractedFull(bytes.into()))
+    }
+
+    fn part(&self) -> Result<ExtractedFull<'a>> {
+        let bytes = match &self.0 {
+            AnyPart::Txt(p) => p.body,
+            AnyPart::Bin(p) => p.body,
+            AnyPart::Msg(p) => p.raw_part,
+            AnyPart::Mult(_) => bail!("Multipart part has no body"),
+        };
+        Ok(ExtractedFull(bytes.to_vec().into()))
+    }
+
+    /// The [...] HEADER.FIELDS, and HEADER.FIELDS.NOT part
+    /// specifiers refer to the [RFC-2822] header of the message or of
+    /// an encapsulated [MIME-IMT] MESSAGE/RFC822 message.
+    /// HEADER.FIELDS and HEADER.FIELDS.NOT are followed by a list of
+    /// field-name (as defined in [RFC-2822]) names, and return a
+    /// subset of the header.  The subset returned by HEADER.FIELDS
+    /// contains only those header fields with a field-name that
+    /// matches one of the names in the list; similarly, the subset
+    /// returned by HEADER.FIELDS.NOT contains only the header fields
+    /// with a non-matching field-name.  The field-matching is
+    /// case-insensitive but otherwise exact.
+    fn header_fields(
+        &self,
+        fields: &'a NonEmptyVec<AString<'a>>,
+        invert: bool,
+    ) -> Result<ExtractedFull<'a>> {
+        // Build a lowercase ascii hashset with the fields to fetch
+        let index = fields
+            .as_ref()
+            .iter()
+            .map(|x| {
+                match x {
+                    AString::Atom(a) => a.inner().as_bytes(),
+                    AString::String(IString::Literal(l)) => l.as_ref(),
+                    AString::String(IString::Quoted(q)) => q.inner().as_bytes(),
+                }
+                .to_ascii_lowercase()
+            })
+            .collect::<HashSet<_>>();
+
+        // Extract MIME headers
+        let mime = match &self.0 {
+            AnyPart::Msg(msg) => msg.child.mime(),
+            other => other.mime(),
+        };
+
+        // Filter our MIME headers based on the field index
+        // 1. Keep only the correctly formatted headers
+        // 2. Keep only based on the index presence or absence
+        // 3. Reduce as a byte vector
+        let buffer = mime
+            .kv
+            .iter()
+            .filter_map(|field| match field {
+                header::Field::Good(header::Kv2(k, v)) => Some((k, v)),
+                _ => None,
+            })
+            .filter(|(k, _)| index.contains(&k.to_ascii_lowercase()) ^ invert)
+            .fold(vec![], |mut acc, (k, v)| {
+                acc.extend(*k);
+                acc.extend(b": ");
+                acc.extend(*v);
+                acc.extend(b"\r\n");
+                acc
+            });
+
+        Ok(ExtractedFull(buffer.into()))
+    }
+
+    /// The HEADER [...] part specifiers refer to the [RFC-2822] header of the message or of
+    /// an encapsulated [MIME-IMT] MESSAGE/RFC822 message.
+    /// ```raw
+    /// HEADER     ([RFC-2822] header of the message)
+    /// ```
+    fn header(&self) -> Result<ExtractedFull<'a>> {
+        let msg = self
+            .0
+            .as_message()
+            .ok_or(anyhow!("Selected part must be a message/rfc822"))?;
+        Ok(ExtractedFull(msg.raw_headers.into()))
+    }
+
+    /// The TEXT part specifier refers to the text body of the message, omitting the [RFC-2822] header.
+    fn text(&self) -> Result<ExtractedFull<'a>> {
+        let msg = self
+            .0
+            .as_message()
+            .ok_or(anyhow!("Selected part must be a message/rfc822"))?;
+        Ok(ExtractedFull(msg.raw_body.into()))
+    }
+
+    // ------------
+
+    /// Basic field of a MIME part that is
+    /// common to all parts
+    fn basic_fields(&self) -> Result<BasicFields<'static>> {
+        let sz = match self.0 {
+            AnyPart::Txt(x) => x.body.len(),
+            AnyPart::Bin(x) => x.body.len(),
+            AnyPart::Msg(x) => x.raw_part.len(),
+            AnyPart::Mult(_) => 0,
+        };
+        let m = self.0.mime();
+        let parameter_list = m
+            .ctype
+            .as_ref()
+            .map(|x| {
+                x.params
+                    .iter()
+                    .map(|p| {
+                        (
+                            IString::try_from(String::from_utf8_lossy(p.name).to_string()),
+                            IString::try_from(p.value.to_string()),
+                        )
+                    })
+                    .filter(|(k, v)| k.is_ok() && v.is_ok())
+                    .map(|(k, v)| (k.unwrap(), v.unwrap()))
+                    .collect()
+            })
+            .unwrap_or(vec![]);
+
+        Ok(BasicFields {
+            parameter_list,
+            id: NString(
+                m.id.as_ref()
+                    .and_then(|ci| IString::try_from(ci.to_string()).ok()),
+            ),
+            description: NString(
+                m.description
+                    .as_ref()
+                    .and_then(|cd| IString::try_from(cd.to_string()).ok()),
+            ),
+            content_transfer_encoding: match m.transfer_encoding {
+                mime::mechanism::Mechanism::_8Bit => unchecked_istring("8bit"),
+                mime::mechanism::Mechanism::Binary => unchecked_istring("binary"),
+                mime::mechanism::Mechanism::QuotedPrintable => {
+                    unchecked_istring("quoted-printable")
+                }
+                mime::mechanism::Mechanism::Base64 => unchecked_istring("base64"),
+                _ => unchecked_istring("7bit"),
+            },
+            // @FIXME we can't compute the size of the message currently...
+            size: u32::try_from(sz)?,
+        })
+    }
+}
+
+// ---------------------------
+struct NodeMsg<'a>(&'a NodeMime<'a>, &'a composite::Message<'a>);
+impl<'a> NodeMsg<'a> {
+    fn structure(&self) -> Result<BodyStructure<'static>> {
+        let basic = SelectedMime(self.0 .0).basic_fields()?;
+
+        Ok(BodyStructure::Single {
+            body: FetchBody {
+                basic,
+                specific: SpecificFields::Message {
+                    envelope: Box::new(message_envelope(&self.1.imf)),
+                    body_structure: Box::new(NodeMime(&self.1.child).structure()?),
+                    number_of_lines: nol(self.1.raw_part),
+                },
+            },
+            extension_data: None,
+        })
+    }
+}
+struct NodeMult<'a>(&'a NodeMime<'a>, &'a composite::Multipart<'a>);
+impl<'a> NodeMult<'a> {
+    fn structure(&self) -> Result<BodyStructure<'static>> {
+        let itype = &self.1.mime.interpreted_type;
+        let subtype = IString::try_from(itype.subtype.to_string())
+            .unwrap_or(unchecked_istring("alternative"));
+
+        let inner_bodies = self
+            .1
+            .children
+            .iter()
+            .filter_map(|inner| NodeMime(&inner).structure().ok())
+            .collect::<Vec<_>>();
+
+        NonEmptyVec::validate(&inner_bodies)?;
+        let bodies = NonEmptyVec::unvalidated(inner_bodies);
+
+        Ok(BodyStructure::Multi {
+            bodies,
+            subtype,
+            extension_data: None,
+            /*Some(MultipartExtensionData {
+            parameter_list: vec![],
+            disposition: None,
+            language: None,
+            location: None,
+            extension: vec![],
+            })*/
+        })
+    }
+}
+struct NodeTxt<'a>(&'a NodeMime<'a>, &'a discrete::Text<'a>);
+impl<'a> NodeTxt<'a> {
+    fn structure(&self) -> Result<BodyStructure<'static>> {
+        let mut basic = SelectedMime(self.0 .0).basic_fields()?;
+
+        // Get the interpreted content type, set it
+        let itype = match &self.1.mime.interpreted_type {
+            Deductible::Inferred(v) | Deductible::Explicit(v) => v,
+        };
+        let subtype =
+            IString::try_from(itype.subtype.to_string()).unwrap_or(unchecked_istring("plain"));
+
+        // Add charset to the list of parameters if we know it has been inferred as it will be
+        // missing from the parsed content.
+        if let Deductible::Inferred(charset) = &itype.charset {
+            basic.parameter_list.push((
+                unchecked_istring("charset"),
+                IString::try_from(charset.to_string()).unwrap_or(unchecked_istring("us-ascii")),
+            ));
+        }
+
+        Ok(BodyStructure::Single {
+            body: FetchBody {
+                basic,
+                specific: SpecificFields::Text {
+                    subtype,
+                    number_of_lines: nol(self.1.body),
+                },
+            },
+            extension_data: None,
+        })
+    }
+}
+
+struct NodeBin<'a>(&'a NodeMime<'a>, &'a discrete::Binary<'a>);
+impl<'a> NodeBin<'a> {
+    fn structure(&self) -> Result<BodyStructure<'static>> {
+        let basic = SelectedMime(self.0 .0).basic_fields()?;
+
+        let default = mime::r#type::NaiveType {
+            main: &b"application"[..],
+            sub: &b"octet-stream"[..],
+            params: vec![],
+        };
+        let ct = self.1.mime.fields.ctype.as_ref().unwrap_or(&default);
+
+        let r#type = IString::try_from(String::from_utf8_lossy(ct.main).to_string()).or(Err(
+            anyhow!("Unable to build IString from given Content-Type type given"),
+        ))?;
+
+        let subtype = IString::try_from(String::from_utf8_lossy(ct.sub).to_string()).or(Err(
+            anyhow!("Unable to build IString from given Content-Type subtype given"),
+        ))?;
+
+        Ok(BodyStructure::Single {
+            body: FetchBody {
+                basic,
+                specific: SpecificFields::Basic { r#type, subtype },
+            },
+            extension_data: None,
+        })
+    }
+}
+
+// ---------------------------
+
+struct ExtractedFull<'a>(Cow<'a, [u8]>);
+impl<'a> ExtractedFull<'a> {
+    /// It is possible to fetch a substring of the designated text.
+    /// This is done by appending an open angle bracket ("<"), the
+    /// octet position of the first desired octet, a period, the
+    /// maximum number of octets desired, and a close angle bracket
+    /// (">") to the part specifier.  If the starting octet is beyond
+    /// the end of the text, an empty string is returned.
+    ///
+    /// Any partial fetch that attempts to read beyond the end of the
+    /// text is truncated as appropriate.  A partial fetch that starts
+    /// at octet 0 is returned as a partial fetch, even if this
+    /// truncation happened.
+    ///
+    /// Note: This means that BODY[]<0.2048> of a 1500-octet message
+    /// will return BODY[]<0> with a literal of size 1500, not
+    /// BODY[].
+    ///
+    /// Note: A substring fetch of a HEADER.FIELDS or
+    /// HEADER.FIELDS.NOT part specifier is calculated after
+    /// subsetting the header.
+    fn to_body_section(self, partial: &'_ Option<(u32, NonZeroU32)>) -> BodySection<'a> {
+        match partial {
+            Some((begin, len)) => self.partialize(*begin, *len),
+            None => BodySection::Full(self.0),
+        }
+    }
+
+    fn partialize(self, begin: u32, len: NonZeroU32) -> BodySection<'a> {
+        // Asked range is starting after the end of the content,
+        // returning an empty buffer
+        if begin as usize > self.0.len() {
+            return BodySection::Slice {
+                body: Cow::Borrowed(&[][..]),
+                origin_octet: begin,
+            };
+        }
+
+        // Asked range is ending after the end of the content,
+        // slice only the beginning of the buffer
+        if (begin + len.get()) as usize >= self.0.len() {
+            return BodySection::Slice {
+                body: match self.0 {
+                    Cow::Borrowed(body) => Cow::Borrowed(&body[begin as usize..]),
+                    Cow::Owned(body) => Cow::Owned(body[begin as usize..].to_vec()),
+                },
+                origin_octet: begin,
+            };
+        }
+
+        // Range is included inside the considered content,
+        // this is the "happy case"
+        BodySection::Slice {
+            body: match self.0 {
+                Cow::Borrowed(body) => {
+                    Cow::Borrowed(&body[begin as usize..(begin + len.get()) as usize])
+                }
+                Cow::Owned(body) => {
+                    Cow::Owned(body[begin as usize..(begin + len.get()) as usize].to_vec())
+                }
+            },
+            origin_octet: begin,
+        }
+    }
+}
+
+/// ---- LEGACY
+
+/// s is set to static to ensure that only compile time values
+/// checked by developpers are passed.
+fn unchecked_istring(s: &'static str) -> IString {
+    IString::try_from(s).expect("this value is expected to be a valid imap-codec::IString")
+}
+
+// Number Of Lines
+fn nol(input: &[u8]) -> u32 {
+    input
+        .iter()
+        .filter(|x| **x == b'\n')
+        .count()
+        .try_into()
+        .unwrap_or(0)
+}

src/imap/mod.rs

@@ -1,8 +1,15 @@
+mod attributes;
 mod capability;
 mod command;
+mod flags;
 mod flow;
+mod imf_view;
+mod index;
+mod mail_view;
 mod mailbox_view;
+mod mime_view;
 mod response;
+mod search;
 mod session;
 
 use std::net::SocketAddr;

src/imap/search.rs

@@ -0,0 +1,130 @@
+use imap_codec::imap_types::core::NonEmptyVec;
+use imap_codec::imap_types::search::SearchKey;
+use imap_codec::imap_types::sequence::{SeqOrUid, Sequence, SequenceSet};
+use std::num::NonZeroU32;
+
+pub enum SeqType {
+    Undefined,
+    NonUid,
+    Uid,
+}
+impl SeqType {
+    pub fn is_uid(&self) -> bool {
+        matches!(self, Self::Uid)
+    }
+}
+
+pub struct Criteria<'a>(pub &'a SearchKey<'a>);
+impl<'a> Criteria<'a> {
+    /// Returns a set of email identifiers that is greater or equal
+    /// to the set of emails to return
+    pub fn to_sequence_set(&self) -> (SequenceSet, SeqType) {
+        match self.0 {
+            SearchKey::All => (sequence_set_all(), SeqType::Undefined),
+            SearchKey::SequenceSet(seq_set) => (seq_set.clone(), SeqType::NonUid),
+            SearchKey::Uid(seq_set) => (seq_set.clone(), SeqType::Uid),
+            SearchKey::Not(_inner) => {
+                tracing::debug!(
+                    "using NOT in a search request is slow: it selects all identifiers"
+                );
+                (sequence_set_all(), SeqType::Undefined)
+            }
+            SearchKey::Or(left, right) => {
+                tracing::debug!("using OR in a search request is slow: no deduplication is done");
+                let (base, base_seqtype) = Self(&left).to_sequence_set();
+                let (ext, ext_seqtype) = Self(&right).to_sequence_set();
+
+                // Check if we have a UID/ID conflict in fetching: now we don't know how to handle them
+                match (base_seqtype, ext_seqtype) {
+                    (SeqType::Uid, SeqType::NonUid) | (SeqType::NonUid, SeqType::Uid) => {
+                        (sequence_set_all(), SeqType::Undefined)
+                    }
+                    (SeqType::Undefined, x) | (x, _) => {
+                        let mut new_vec = base.0.into_inner();
+                        new_vec.extend_from_slice(ext.0.as_ref());
+                        let seq = SequenceSet(
+                            NonEmptyVec::try_from(new_vec)
+                                .expect("merging non empty vec lead to non empty vec"),
+                        );
+                        (seq, x)
+                    }
+                }
+            }
+            SearchKey::And(search_list) => {
+                tracing::debug!(
+                    "using AND in a search request is slow: no intersection is performed"
+                );
+                search_list
+                    .as_ref()
+                    .iter()
+                    .map(|crit| Self(&crit).to_sequence_set())
+                    .min_by(|(x, _), (y, _)| {
+                        let x_size = approx_sequence_set_size(x);
+                        let y_size = approx_sequence_set_size(y);
+                        x_size.cmp(&y_size)
+                    })
+                    .unwrap_or((sequence_set_all(), SeqType::Undefined))
+            }
+            _ => (sequence_set_all(), SeqType::Undefined),
+        }
+    }
+
+    /// Not really clever as we can have cases where we filter out
+    /// the email before needing to inspect its meta.
+    /// But for now we are seeking the most basic/stupid algorithm.
+    pub fn need_meta(&self) -> bool {
+        use SearchKey::*;
+        match self.0 {
+            // IMF Headers
+            Bcc(_) | Cc(_) | From(_) | Header(..) | SentBefore(_) | SentOn(_) | SentSince(_)
+            | Subject(_) | To(_) => true,
+            // Internal Date is also stored in MailMeta
+            Before(_) | On(_) | Since(_) => true,
+            // Message size is also stored in MailMeta
+            Larger(_) | Smaller(_) => true,
+            And(and_list) => and_list.as_ref().iter().any(|sk| Criteria(sk).need_meta()),
+            Not(inner) => Criteria(inner).need_meta(),
+            Or(left, right) => Criteria(left).need_meta() || Criteria(right).need_meta(),
+            _ => false,
+        }
+    }
+
+    pub fn need_body(&self) -> bool {
+        use SearchKey::*;
+        match self.0 {
+            Text(_) | Body(_) => true,
+            And(and_list) => and_list.as_ref().iter().any(|sk| Criteria(sk).need_body()),
+            Not(inner) => Criteria(inner).need_body(),
+            Or(left, right) => Criteria(left).need_body() || Criteria(right).need_body(),
+            _ => false,
+        }
+    }
+}
+
+fn sequence_set_all() -> SequenceSet {
+    SequenceSet::from(Sequence::Range(
+        SeqOrUid::Value(NonZeroU32::MIN),
+        SeqOrUid::Asterisk,
+    ))
+}
+
+// This is wrong as sequences can overlap
+fn approx_sequence_set_size(seq_set: &SequenceSet) -> u64 {
+    seq_set.0.as_ref().iter().fold(0u64, |acc, seq| {
+        acc.saturating_add(approx_sequence_size(seq))
+    })
+}
+
+// This is wrong as sequence UID can have holes,
+// as we don't know the number of messages in the mailbox also
+fn approx_sequence_size(seq: &Sequence) -> u64 {
+    match seq {
+        Sequence::Single(_) => 1,
+        Sequence::Range(SeqOrUid::Asterisk, _) | Sequence::Range(_, SeqOrUid::Asterisk) => u64::MAX,
+        Sequence::Range(SeqOrUid::Value(x1), SeqOrUid::Value(x2)) => {
+            let x2 = x2.get() as i64;
+            let x1 = x1.get() as i64;
+            (x2 - x1).abs().try_into().unwrap_or(1)
+        }
+    }
+}

src/mail/mailbox.rs

@@ -82,6 +82,10 @@ impl Mailbox {
         self.mbox.read().await.fetch_full(id, message_key).await
     }
 
+    pub async fn frozen(self: &std::sync::Arc<Self>) -> super::snapshot::FrozenMailbox {
+        super::snapshot::FrozenMailbox::new(self.clone()).await
+    }
+
     // ---- Functions for changing the mailbox ----
 
     /// Add flags to message
@@ -149,7 +153,6 @@ impl Mailbox {
 
     /// Move an email from an other Mailbox to this mailbox
     /// (use this when possible, as it allows for a certain number of storage optimizations)
-    #[allow(dead_code)]
     pub async fn move_from(&self, from: &Mailbox, uuid: UniqueIdent) -> Result<()> {
         if self.id == from.id {
             bail!("Cannot copy move same mailbox");
@@ -403,8 +406,6 @@ impl MailboxInternal {
         Ok(new_id)
     }
 
-    #[allow(dead_code)]
-    // 2023-05-15 will probably be used later
     async fn move_from(&mut self, from: &mut MailboxInternal, id: UniqueIdent) -> Result<()> {
         self.copy_internal(from, id, id).await?;
         from.delete(id).await?;

src/mail/mod.rs

@@ -3,6 +3,8 @@ use std::io::Write;
 
 pub mod incoming;
 pub mod mailbox;
+pub mod query;
+pub mod snapshot;
 pub mod uidindex;
 pub mod unique_ident;
 pub mod user;

src/mail/query.rs

@@ -0,0 +1,170 @@
+use super::mailbox::MailMeta;
+use super::snapshot::FrozenMailbox;
+use super::uidindex::IndexEntry;
+use super::unique_ident::UniqueIdent;
+use anyhow::{anyhow, Result};
+use futures::stream::{FuturesUnordered, StreamExt};
+
+/// Query is in charge of fetching efficiently
+/// requested data for a list of emails
+pub struct Query<'a, 'b> {
+    pub frozen: &'a FrozenMailbox,
+    pub emails: &'b [UniqueIdent],
+    pub scope: QueryScope,
+}
+
+#[allow(dead_code)]
+pub enum QueryScope {
+    Index,
+    Partial,
+    Full,
+}
+
+impl<'a, 'b> Query<'a, 'b> {
+    pub async fn fetch(&self) -> Result<Vec<QueryResult<'a>>> {
+        match self.scope {
+            QueryScope::Index => self.index(),
+            QueryScope::Partial => self.partial().await,
+            QueryScope::Full => self.full().await,
+        }
+    }
+
+    // --- functions below are private *for reasons*
+
+    fn index(&self) -> Result<Vec<QueryResult<'a>>> {
+        self.emails
+            .iter()
+            .map(|uuid| {
+                self.frozen
+                    .snapshot
+                    .table
+                    .get(uuid)
+                    .map(|index| QueryResult::IndexResult { uuid: *uuid, index })
+                    .ok_or(anyhow!("missing email in index"))
+            })
+            .collect::<Result<Vec<_>, _>>()
+    }
+
+    async fn partial(&self) -> Result<Vec<QueryResult<'a>>> {
+        let meta = self.frozen.mailbox.fetch_meta(self.emails).await?;
+        let result = meta
+            .into_iter()
+            .zip(self.index()?)
+            .map(|(metadata, index)| {
+                index
+                    .into_partial(metadata)
+                    .expect("index to be IndexResult")
+            })
+            .collect::<Vec<_>>();
+        Ok(result)
+    }
+
+    /// @FIXME WARNING: THIS CAN ALLOCATE A LOT OF MEMORY
+    /// AND GENERATE SO MUCH NETWORK TRAFFIC.
+    /// THIS FUNCTION SHOULD BE REWRITTEN, FOR EXAMPLE WITH
+    /// SOMETHING LIKE AN ITERATOR
+    async fn full(&self) -> Result<Vec<QueryResult<'a>>> {
+        let meta_list = self.partial().await?;
+        meta_list
+            .into_iter()
+            .map(|meta| async move {
+                let content = self
+                    .frozen
+                    .mailbox
+                    .fetch_full(
+                        *meta.uuid(),
+                        &meta
+                            .metadata()
+                            .expect("meta to be PartialResult")
+                            .message_key,
+                    )
+                    .await?;
+
+                Ok(meta.into_full(content).expect("meta to be PartialResult"))
+            })
+            .collect::<FuturesUnordered<_>>()
+            .collect::<Vec<_>>()
+            .await
+            .into_iter()
+            .collect::<Result<Vec<_>, _>>()
+    }
+}
+
+pub enum QueryResult<'a> {
+    IndexResult {
+        uuid: UniqueIdent,
+        index: &'a IndexEntry,
+    },
+    PartialResult {
+        uuid: UniqueIdent,
+        index: &'a IndexEntry,
+        metadata: MailMeta,
+    },
+    FullResult {
+        uuid: UniqueIdent,
+        index: &'a IndexEntry,
+        metadata: MailMeta,
+        content: Vec<u8>,
+    },
+}
+impl<'a> QueryResult<'a> {
+    pub fn uuid(&self) -> &UniqueIdent {
+        match self {
+            Self::IndexResult { uuid, .. } => uuid,
+            Self::PartialResult { uuid, .. } => uuid,
+            Self::FullResult { uuid, .. } => uuid,
+        }
+    }
+
+    #[allow(dead_code)]
+    pub fn index(&self) -> &IndexEntry {
+        match self {
+            Self::IndexResult { index, .. } => index,
+            Self::PartialResult { index, .. } => index,
+            Self::FullResult { index, .. } => index,
+        }
+    }
+
+    pub fn metadata(&'a self) -> Option<&'a MailMeta> {
+        match self {
+            Self::IndexResult { .. } => None,
+            Self::PartialResult { metadata, .. } => Some(metadata),
+            Self::FullResult { metadata, .. } => Some(metadata),
+        }
+    }
+
+    #[allow(dead_code)]
+    pub fn content(&'a self) -> Option<&'a [u8]> {
+        match self {
+            Self::FullResult { content, .. } => Some(content),
+            _ => None,
+        }
+    }
+
+    fn into_partial(self, metadata: MailMeta) -> Option<Self> {
+        match self {
+            Self::IndexResult { uuid, index } => Some(Self::PartialResult {
+                uuid,
+                index,
+                metadata,
+            }),
+            _ => None,
+        }
+    }
+
+    fn into_full(self, content: Vec<u8>) -> Option<Self> {
+        match self {
+            Self::PartialResult {
+                uuid,
+                index,
+                metadata,
+            } => Some(Self::FullResult {
+                uuid,
+                index,
+                metadata,
+                content,
+            }),
+            _ => None,
+        }
+    }
+}

src/mail/snapshot.rs

@@ -0,0 +1,62 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+
+use super::mailbox::Mailbox;
+use super::query::{Query, QueryScope};
+use super::uidindex::UidIndex;
+use super::unique_ident::UniqueIdent;
+
+/// A Frozen Mailbox has a snapshot of the current mailbox
+/// state that is desynchronized with the real mailbox state.
+/// It's up to the user to choose when their snapshot must be updated
+/// to give useful information to their clients
+///
+///
+pub struct FrozenMailbox {
+    pub mailbox: Arc<Mailbox>,
+    pub snapshot: UidIndex,
+}
+
+impl FrozenMailbox {
+    /// Create a snapshot from a mailbox, the mailbox + the snapshot
+    /// becomes the "Frozen Mailbox".
+    pub async fn new(mailbox: Arc<Mailbox>) -> Self {
+        let state = mailbox.current_uid_index().await;
+
+        Self {
+            mailbox,
+            snapshot: state,
+        }
+    }
+
+    /// Force the synchronization of the inner mailbox
+    /// but do not update the local snapshot
+    pub async fn sync(&self) -> Result<()> {
+        self.mailbox.opportunistic_sync().await
+    }
+
+    /// Peek snapshot without updating the frozen mailbox
+    /// Can be useful if you want to plan some writes
+    /// while sending a diff to the client later
+    pub async fn peek(&self) -> UidIndex {
+        self.mailbox.current_uid_index().await
+    }
+
+    /// Update the FrozenMailbox local snapshot.
+    /// Returns the old snapshot, so you can build a diff
+    pub async fn update(&mut self) -> UidIndex {
+        let old_snapshot = self.snapshot.clone();
+        self.snapshot = self.mailbox.current_uid_index().await;
+
+        old_snapshot
+    }
+
+    pub fn query<'a, 'b>(&'a self, uuids: &'b [UniqueIdent], scope: QueryScope) -> Query<'a, 'b> {
+        Query {
+            frozen: self,
+            emails: uuids,
+            scope,
+        }
+    }
+}

src/mail/uidindex.rs

@@ -9,6 +9,7 @@ use crate::mail::unique_ident::UniqueIdent;
 pub type ImapUid = NonZeroU32;
 pub type ImapUidvalidity = NonZeroU32;
 pub type Flag = String;
+pub type IndexEntry = (ImapUid, Vec<Flag>);
 
 /// A UidIndex handles the mutable part of a mailbox
 /// It is built by running the event log on it
@@ -18,7 +19,7 @@ pub type Flag = String;
 #[derive(Clone)]
 pub struct UidIndex {
     // Source of trust
-    pub table: OrdMap<UniqueIdent, (ImapUid, Vec<Flag>)>,
+    pub table: OrdMap<UniqueIdent, IndexEntry>,
 
     // Indexes optimized for queries
     pub idx_by_uid: OrdMap<ImapUid, UniqueIdent>,

tests/behavior.rs

@@ -26,15 +26,18 @@ fn rfc3501_imap4rev1_base() {
         lmtp_handshake(lmtp_socket).context("handshake lmtp done")?;
         lmtp_deliver_email(lmtp_socket, Email::Multipart).context("mail delivered successfully")?;
         noop_exists(imap_socket).context("noop loop must detect a new email")?;
-        fetch_rfc822(imap_socket, Selection::FirstId, Email::Multipart).context("fetch rfc822 message, should be our first message")?;
-        copy(imap_socket, Selection::FirstId, Mailbox::Archive).context("copy message to the archive mailbox")?;
+        fetch_rfc822(imap_socket, Selection::FirstId, Email::Multipart)
+            .context("fetch rfc822 message, should be our first message")?;
+        copy(imap_socket, Selection::FirstId, Mailbox::Archive)
+            .context("copy message to the archive mailbox")?;
         append_email(imap_socket, Email::Basic).context("insert email in INBOX")?;
         // SEARCH IS NOT IMPLEMENTED YET
         //search(imap_socket).expect("search should return something");
         add_flags_email(imap_socket, Selection::FirstId, Flag::Deleted)
             .context("should add delete flag to the email")?;
         expunge(imap_socket).context("expunge emails")?;
-        rename_mailbox(imap_socket, Mailbox::Archive, Mailbox::Drafts).context("Archive mailbox is renamed Drafts")?;
+        rename_mailbox(imap_socket, Mailbox::Archive, Mailbox::Drafts)
+            .context("Archive mailbox is renamed Drafts")?;
         delete_mailbox(imap_socket, Mailbox::Drafts).context("Drafts mailbox is deleted")?;
         Ok(())
     })
@@ -53,13 +56,16 @@ fn rfc3691_imapext_unselect() {
         login(imap_socket, Account::Alice).context("login test")?;
         select(imap_socket, Mailbox::Inbox, None).context("select inbox")?;
         noop_exists(imap_socket).context("noop loop must detect a new email")?;
-        add_flags_email(imap_socket, Selection::FirstId, Flag::Deleted).context("add delete flags to the email")?;
+        add_flags_email(imap_socket, Selection::FirstId, Flag::Deleted)
+            .context("add delete flags to the email")?;
         unselect(imap_socket)
             .context("unselect inbox while preserving email with the \\Delete flag")?;
         select(imap_socket, Mailbox::Inbox, Some(1)).context("select inbox again")?;
-        fetch_rfc822(imap_socket, Selection::FirstId, Email::Basic).context("message is still present")?;
+        fetch_rfc822(imap_socket, Selection::FirstId, Email::Basic)
+            .context("message is still present")?;
         close(imap_socket).context("close inbox and expunge message")?;
-        select(imap_socket, Mailbox::Inbox, Some(0)).context("select inbox again and check it's empty")?;
+        select(imap_socket, Mailbox::Inbox, Some(0))
+            .context("select inbox again and check it's empty")?;
 
         Ok(())
     })
@@ -94,7 +100,8 @@ fn rfc6851_imapext_move() {
         lmtp_deliver_email(lmtp_socket, Email::Basic).context("mail delivered successfully")?;
 
         noop_exists(imap_socket).context("noop loop must detect a new email")?;
-        r#move(imap_socket, Selection::FirstId, Mailbox::Archive).context("message from inbox moved to archive")?;
+        r#move(imap_socket, Selection::FirstId, Mailbox::Archive)
+            .context("message from inbox moved to archive")?;
 
         unselect(imap_socket)
             .context("unselect inbox while preserving email with the \\Delete flag")?;
@@ -116,5 +123,6 @@ fn rfc7888_imapext_literal() {
         login_with_literal(imap_socket, Account::Alice).context("use literal to connect Alice")?;
 
         Ok(())
-    }).expect("test fully run");
+    })
+    .expect("test fully run");
 }

tests/common/fragments.rs

@@ -52,7 +52,7 @@ pub enum Mailbox {
 
 pub enum Flag {
     Deleted,
-    Important
+    Important,
 }
 
 pub enum Email {
@@ -287,8 +287,6 @@ pub fn append_email(imap: &mut TcpStream, content: Email) -> Result<()> {
     Ok(())
 }
 
-
-
 pub fn add_flags_email(imap: &mut TcpStream, selection: Selection, flag: Flag) -> Result<()> {
     let mut buffer: [u8; 1500] = [0; 1500];
     assert!(matches!(selection, Selection::FirstId));
@@ -390,7 +388,7 @@ pub fn enable(imap: &mut TcpStream, ask: Enable, done: Option<Enable>) -> Result
         Some(Enable::Utf8Accept) => {
             assert_eq!(srv_msg.lines().count(), 2);
             assert!(srv_msg.contains("* ENABLED UTF8=ACCEPT"));
-        },
+        }
         _ => unimplemented!(),
     }