Deuxfleurs
/
aerogramme
15
0
Fork 1
Code Issues 33 Pull Requests 1 Projects 11 Releases 4 Wiki Activity

Handle select

This commit is contained in:
Quentin 2022-06-13 18:01:07 +02:00
parent 7113809cb7
commit 12b379e7c3
Signed by: quentin
GPG Key ID: E9602264D639FF68
4 changed files with 90 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

79
src/command.rs
View File

@ -1,5 +1,6 @@
use boitalettres::errors::Error as BalError;
use anyhow::Result;
use boitalettres::proto::{Request, Response};
use boitalettres::errors::Error as BalError;
use imap_codec::types::core::{Tag, AString};
use imap_codec::types::response::{Capability, Data};
use imap_codec::types::mailbox::{Mailbox as MailboxCodec, ListMailbox};
@ -20,7 +21,7 @@ impl<'a> Command<'a> {
Self { tag, session }
}
pub async fn capability(&self) -> Result<Response, BalError> {
pub async fn capability(&self) -> Result<Response> {
let capabilities = vec![Capability::Imap4Rev1, Capability::Idle];
let body = vec![Data::Capability(capabilities)];
let r = Response::ok("Pre-login capabilities listed, post-login capabilities have more.")?
@ -28,52 +29,68 @@ impl<'a> Command<'a> {
Ok(r)
}
pub async fn login(&mut self, username: AString, password: AString) -> Result<Response, BalError> {
let (u, p) = match (String::try_from(username), String::try_from(password)) {
(Ok(u), Ok(p)) => (u, p),
_ => return Response::bad("Invalid characters"),
};
pub async fn login(&mut self, username: AString, password: AString) -> Result<Response> {
let (u, p) = (String::try_from(username)?, String::try_from(password)?);
tracing::info!(user = %u, "command.login");
tracing::debug!(user = %u, "command.login");
let creds = match self.session.mailstore.login_provider.login(&u, &p).await {
Err(_) => return Response::no("[AUTHENTICATIONFAILED] Authentication failed."),
Err(_) => return Ok(Response::no("[AUTHENTICATIONFAILED] Authentication failed.")?),
Ok(c) => c,
};
self.session.creds = Some(creds);
self.session.username = Some(u.clone());
self.session.user = Some(session::User { creds, name: u.clone(), });
tracing::info!(username=%u, "connected");
Response::ok("Logged in")
Ok(Response::ok("Logged in")?)
}
pub async fn lsub(&self, reference: MailboxCodec, mailbox_wildcard: ListMailbox) -> Result<Response, BalError> {
Response::bad("Not implemented")
pub async fn lsub(&self, reference: MailboxCodec, mailbox_wildcard: ListMailbox) -> Result<Response> {
Ok(Response::bad("Not implemented")?)
}
pub async fn list(&self, reference: MailboxCodec, mailbox_wildcard: ListMailbox) -> Result<Response, BalError> {
Response::bad("Not implemented")
pub async fn list(&self, reference: MailboxCodec, mailbox_wildcard: ListMailbox) -> Result<Response> {
Ok(Response::bad("Not implemented")?)
}
pub async fn select(&mut self, mailbox: MailboxCodec) -> Result<Response, BalError> {
let (name, creds) = match (String::try_from(mailbox), self.session.creds.as_ref()) {
(Ok(n), Some(c)) => (n, c),
(_, None) => return Response::no("You must be connected to use SELECT"),
(Err(e), _) => {
tracing::warn!("Unable to decode mailbox name: {:#?}", e);
return Response::bad("Unable to decode mailbox name")
},
/*
* 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
* TRACE END ---
*/
pub async fn select(&mut self, mailbox: MailboxCodec) -> Result<Response> {
let name = String::try_from(mailbox)?;
let user = match self.session.user.as_ref() {
Some(u) => u,
_ => return Ok(Response::no("You must be connected to use SELECT")?),
};
let mb = Mailbox::new(creds, name.clone()).unwrap();
self.session.selected = Some(mb);
let user = self.session.username.as_ref().unwrap();
let mut mb = Mailbox::new(&user.creds, name.clone())?;
tracing::info!(username=%user.name, mailbox=%name, "mailbox.selected");
tracing::info!(username=%user, mailbox=%name, "mailbox-selected");
Response::bad("Not implemented")
let sum = mb.summary().await?;
tracing::trace!(summary=%sum, "mailbox.summary");
let body = vec![
Data::Exists(sum.exists.try_into()?),
Data::Recent(0),
];
self.session.selected = Some(mb);
Ok(Response::ok("[READ-WRITE] Select completed")?.with_body(body))
}
pub async fn fetch(&self, sequence_set: SequenceSet, attributes: MacroOrFetchAttributes, uid: bool) -> Result<Response, BalError> {
Response::bad("Not implemented")
pub async fn fetch(&self, sequence_set: SequenceSet, attributes: MacroOrFetchAttributes, uid: bool) -> Result<Response> {
Ok(Response::bad("Not implemented")?)
}
}

22
src/mailbox.rs
View File

@ -8,6 +8,17 @@ use crate::cryptoblob::Key;
use crate::login::Credentials;
use crate::uidindex::*;
pub struct Summary {
pub validity: ImapUidvalidity,
pub next: ImapUid,
pub exists: usize,
}
impl std::fmt::Display for Summary {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "uidvalidity: {}, uidnext: {}, exists: {}", self.validity, self.next, self.exists)
}
}
pub struct Mailbox {
bucket: String,
pub name: String,
@ -33,6 +44,17 @@ impl Mailbox {
})
}
pub async fn summary(&mut self) -> Result<Summary> {
self.uid_index.sync().await?;
let state = self.uid_index.state();
return Ok(Summary {
validity: state.uidvalidity,
next: state.uidnext,
exists: state.mail_uid.len(),
})
}
pub async fn test(&mut self) -> Result<()> {
self.uid_index.sync().await?;

22
src/session.rs
View File

@ -66,17 +66,21 @@ impl Manager {
}
}
pub struct User {
pub name: String,
pub creds: Credentials,
}
pub struct Instance {
rx: mpsc::Receiver<Message>,
pub mailstore: Arc<Mailstore>,
pub creds: Option<Credentials>,
pub selected: Option<Mailbox>,
pub username: Option<String>,
pub user: Option<User>,
}
impl Instance {
fn new(mailstore: Arc<Mailstore>, rx: mpsc::Receiver<Message>) -> Self {
Self { mailstore, rx, creds: None, selected: None, username: None, }
Self { mailstore, rx, selected: None, user: None, }
}
//@FIXME add a function that compute the runner's name from its local info
@ -96,12 +100,20 @@ impl Instance {
CommandBody::List { reference, mailbox_wildcard } => cmd.list(reference, mailbox_wildcard).await,
CommandBody::Select { mailbox } => cmd.select(mailbox).await,
CommandBody::Fetch { sequence_set, attributes, uid } => cmd.fetch(sequence_set, attributes, uid).await,
_ => Response::bad("Error in IMAP command received by server."),
_ => Response::bad("Error in IMAP command received by server.").map_err(anyhow::Error::new),
};
let wrapped_res = res.or_else(|e| match e.downcast::<BalError>() {
Ok(be) => Err(be),
Err(ae) => {
tracing::warn!(error=%ae, "internal.error");
Response::bad("Internal error")
}
});
//@FIXME I think we should quit this thread on error and having our manager watch it,
// and then abort the session as it is corrupted.
msg.tx.send(res).unwrap_or_else(|e| tracing::warn!("failed to send imap response to manager: {:#?}", e));
msg.tx.send(wrapped_res).unwrap_or_else(|e| tracing::warn!("failed to send imap response to manager: {:#?}", e));
}
//@FIXME add more info about the runner

5
src/uidindex.rs
View File

@ -3,8 +3,8 @@ use serde::{de::Error, Deserialize, Deserializer, Serialize, Serializer};
use crate::bayou::*;
type ImapUid = u32;
type ImapUidvalidity = u32;
pub type ImapUid = u32;
pub type ImapUidvalidity = u32;
/// A Mail UUID is composed of two components:
/// - a process identifier, 128 bits
@ -19,6 +19,7 @@ pub struct UidIndex {
pub mails_by_uid: OrdMap<ImapUid, MailUuid>,
pub uidvalidity: ImapUidvalidity,
pub uidnext: ImapUid,
pub internalseq: ImapUid,