use std::collections::BTreeMap; use std::sync::Arc; use anyhow::{anyhow, Result}; use boitalettres::proto::{Request, Response}; use imap_codec::types::command::{CommandBody, StatusAttribute}; use imap_codec::types::flag::FlagNameAttribute; use imap_codec::types::mailbox::{ListMailbox, Mailbox as MailboxCodec}; use imap_codec::types::response::{Code, Data}; use crate::imap::command::anonymous; use crate::imap::flow; use crate::imap::mailbox_view::MailboxView; use crate::mail::user::{User, INBOX, MAILBOX_HIERARCHY_DELIMITER}; pub struct AuthenticatedContext<'a> { pub req: &'a Request, pub user: &'a Arc, } pub async fn dispatch<'a>(ctx: AuthenticatedContext<'a>) -> Result<(Response, flow::Transition)> { match &ctx.req.command.body { CommandBody::Create { mailbox } => ctx.create(mailbox).await, CommandBody::Delete { mailbox } => ctx.delete(mailbox).await, CommandBody::Rename { mailbox, new_mailbox, } => ctx.rename(mailbox, new_mailbox).await, CommandBody::Lsub { reference, mailbox_wildcard, } => ctx.list(reference, mailbox_wildcard, true).await, CommandBody::List { reference, mailbox_wildcard, } => ctx.list(reference, mailbox_wildcard, false).await, CommandBody::Status { mailbox, attributes, } => ctx.status(mailbox, attributes).await, CommandBody::Subscribe { mailbox } => ctx.subscribe(mailbox).await, CommandBody::Unsubscribe { mailbox } => ctx.unsubscribe(mailbox).await, CommandBody::Select { mailbox } => ctx.select(mailbox).await, CommandBody::Examine { mailbox } => ctx.examine(mailbox).await, _ => { let ctx = anonymous::AnonymousContext { req: ctx.req, login_provider: None, }; anonymous::dispatch(ctx).await } } } // --- PRIVATE --- impl<'a> AuthenticatedContext<'a> { async fn create(self, mailbox: &MailboxCodec) -> Result<(Response, flow::Transition)> { let name = String::try_from(mailbox.clone())?; if name == INBOX { return Ok(( Response::bad("Cannot create INBOX")?, flow::Transition::None, )); } match self.user.create_mailbox(&name).await { Ok(()) => Ok((Response::ok("CREATE complete")?, flow::Transition::None)), Err(e) => Ok((Response::no(&e.to_string())?, flow::Transition::None)), } } async fn delete(self, mailbox: &MailboxCodec) -> Result<(Response, flow::Transition)> { let name = String::try_from(mailbox.clone())?; match self.user.delete_mailbox(&name).await { Ok(()) => Ok((Response::ok("DELETE complete")?, flow::Transition::None)), Err(e) => Ok((Response::no(&e.to_string())?, flow::Transition::None)), } } async fn rename( self, mailbox: &MailboxCodec, new_mailbox: &MailboxCodec, ) -> Result<(Response, flow::Transition)> { let name = String::try_from(mailbox.clone())?; let new_name = String::try_from(new_mailbox.clone())?; match self.user.rename_mailbox(&name, &new_name).await { Ok(()) => Ok((Response::ok("RENAME complete")?, flow::Transition::None)), Err(e) => Ok((Response::no(&e.to_string())?, flow::Transition::None)), } } async fn list( self, reference: &MailboxCodec, mailbox_wildcard: &ListMailbox, is_lsub: bool, ) -> Result<(Response, flow::Transition)> { let reference = String::try_from(reference.clone())?; if !reference.is_empty() { return Ok(( Response::bad("References not supported")?, flow::Transition::None, )); } let mailboxes = self.user.list_mailboxes().await?; let mut vmailboxes = BTreeMap::new(); for mb in mailboxes.iter() { for (i, _) in mb.match_indices(MAILBOX_HIERARCHY_DELIMITER) { if i > 0 { let smb = &mb[..i]; if !vmailboxes.contains_key(&smb) { vmailboxes.insert(smb, false); } } } vmailboxes.insert(mb, true); } let wildcard = String::try_from(mailbox_wildcard.clone())?; let wildcard_pat = globset::Glob::new(&wildcard)?.compile_matcher(); let mut ret = vec![]; for (mb, is_real) in vmailboxes.iter() { if wildcard_pat.is_match(mb) { let mailbox = mb .to_string() .try_into() .map_err(|_| anyhow!("invalid mailbox name"))?; let mut items = vec![]; if !*is_real { items.push(FlagNameAttribute::Noselect); } if is_lsub { items.push(FlagNameAttribute::Extension( "\\Subscribed".try_into().unwrap(), )); ret.push(Data::Lsub { items, delimiter: Some(MAILBOX_HIERARCHY_DELIMITER), mailbox, }); } else { ret.push(Data::List { items, delimiter: Some(MAILBOX_HIERARCHY_DELIMITER), mailbox, }); } } } Ok(( Response::ok("LIST completed")?.with_body(ret), flow::Transition::None, )) } async fn status( self, mailbox: &MailboxCodec, attributes: &[StatusAttribute], ) -> Result<(Response, flow::Transition)> { let name = String::try_from(mailbox.clone())?; Ok((Response::bad("Not implemented")?, flow::Transition::None)) } async fn subscribe(self, mailbox: &MailboxCodec) -> Result<(Response, flow::Transition)> { let name = String::try_from(mailbox.clone())?; Ok((Response::bad("Not implemented")?, flow::Transition::None)) } async fn unsubscribe(self, mailbox: &MailboxCodec) -> Result<(Response, flow::Transition)> { let name = String::try_from(mailbox.clone())?; Ok(( Response::bad("Aerogramme does not support unsubscribing from a mailbox")?, flow::Transition::None, )) } /* * TRACE BEGIN --- Example: C: A142 SELECT INBOX S: * 172 EXISTS S: * 1 RECENT S: * OK [UNSEEN 12] Message 12 is first unseen S: * OK [UIDVALIDITY 3857529045] UIDs valid S: * OK [UIDNEXT 4392] Predicted next UID S: * FLAGS (\Answered \Flagged \Deleted \Seen \Draft) S: * OK [PERMANENTFLAGS (\Deleted \Seen \*)] Limited S: A142 OK [READ-WRITE] SELECT completed --- a mailbox with no unseen message -> no unseen entry 20 select "INBOX.achats" * FLAGS (\Answered \Flagged \Deleted \Seen \Draft $Forwarded JUNK $label1) * OK [PERMANENTFLAGS (\Answered \Flagged \Deleted \Seen \Draft $Forwarded JUNK $label1 \*)] Flags permitted. * 88 EXISTS * 0 RECENT * OK [UIDVALIDITY 1347986788] UIDs valid * OK [UIDNEXT 91] Predicted next UID * OK [HIGHESTMODSEQ 72] Highest 20 OK [READ-WRITE] Select completed (0.001 + 0.000 secs). * TRACE END --- */ async fn select(self, mailbox: &MailboxCodec) -> Result<(Response, flow::Transition)> { let name = String::try_from(mailbox.clone())?; let mb_opt = self.user.open_mailbox(&name).await?; let mb = match mb_opt { Some(mb) => mb, None => { return Ok(( Response::no("Mailbox does not exist")?, flow::Transition::None, )) } }; tracing::info!(username=%self.user.username, mailbox=%name, "mailbox.selected"); let (mb, data) = MailboxView::new(mb).await?; Ok(( Response::ok("Select completed")? .with_extra_code(Code::ReadWrite) .with_body(data), flow::Transition::Select(mb), )) } async fn examine(self, mailbox: &MailboxCodec) -> Result<(Response, flow::Transition)> { let name = String::try_from(mailbox.clone())?; let mb_opt = self.user.open_mailbox(&name).await?; let mb = match mb_opt { Some(mb) => mb, None => { return Ok(( Response::no("Mailbox does not exist")?, flow::Transition::None, )) } }; tracing::info!(username=%self.user.username, mailbox=%name, "mailbox.examined"); let (mb, data) = MailboxView::new(mb).await?; Ok(( Response::ok("Examine completed")? .with_extra_code(Code::ReadOnly) .with_body(data), flow::Transition::Examine(mb), )) } }