Merge pull request 'Aerogramme refactoring' (#57) from feat/more-imap-qol into main
Reviewed-on: #57
This commit is contained in:
commit
44ca458c5c
20 changed files with 1609 additions and 1043 deletions
2
Cargo.lock
generated
2
Cargo.lock
generated
|
|
@ -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",
|
||||
|
|
|
|||
|
|
@ -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]
|
||||
|
|
|
|||
49
src/imap/attributes.rs
Normal file
49
src/imap/attributes.rs
Normal file
|
|
@ -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
|
||||
)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
|
@ -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((
|
||||
|
|
|
|||
|
|
@ -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((
|
||||
|
|
|
|||
30
src/imap/flags.rs
Normal file
30
src/imap/flags.rs
Normal file
|
|
@ -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,
|
||||
}
|
||||
}
|
||||
97
src/imap/imf_view.rs
Normal file
97
src/imap/imf_view.rs
Normal file
|
|
@ -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(),
|
||||
)),
|
||||
}
|
||||
}
|
||||
95
src/imap/index.rs
Normal file
95
src/imap/index.rs
Normal file
|
|
@ -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>,
|
||||
}
|
||||
247
src/imap/mail_view.rs
Normal file
247
src/imap/mail_view.rs
Normal file
|
|
@ -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"),
|
||||
}
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load diff
538
src/imap/mime_view.rs
Normal file
538
src/imap/mime_view.rs
Normal file
|
|
@ -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)
|
||||
}
|
||||
|
|
@ -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;
|
||||
|
|
|
|||
130
src/imap/search.rs
Normal file
130
src/imap/search.rs
Normal file
|
|
@ -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)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -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?;
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
170
src/mail/query.rs
Normal file
170
src/mail/query.rs
Normal file
|
|
@ -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,
|
||||
}
|
||||
}
|
||||
}
|
||||
62
src/mail/snapshot.rs
Normal file
62
src/mail/snapshot.rs
Normal file
|
|
@ -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,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -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>,
|
||||
|
|
|
|||
|
|
@ -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");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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!(),
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue