Merge QUOTA support

Author: link2xt

src/client.rs

@@ -9,13 +9,14 @@ use async_std::channel;
 use async_std::io::{self, Read, Write};
 use async_std::net::{TcpStream, ToSocketAddrs};
 use async_std::prelude::*;
+use extensions::quota::parse_get_quota_root;
 use imap_proto::{RequestId, Response};
 
 use super::authenticator::Authenticator;
 use super::error::{Error, ParseError, Result, ValidateError};
 use super::parse::*;
 use super::types::*;
-use crate::extensions;
+use crate::extensions::{self, quota::parse_get_quota};
 use crate::imap_stream::ImapStream;
 
 macro_rules! quote {
@@ -1245,6 +1246,37 @@ impl<T: Read + Write + Unpin + fmt::Debug + Send> Session<T> {
         Ok(uids)
     }
 
+    /// The [`GETQUOTA` command](https://tools.ietf.org/html/rfc2087#section-4.2)
+    pub async fn get_quota(&mut self, quota_root: &str) -> Result<Quota> {
+        let id = self
+            .run_command(format!("GETQUOTA {}", quote!(quota_root)))
+            .await?;
+        let c = parse_get_quota(
+            &mut self.conn.stream,
+            self.unsolicited_responses_tx.clone(),
+            id,
+        )
+        .await?;
+        Ok(c)
+    }
+
+    /// The [`GETQUOTAROOT` command](https://tools.ietf.org/html/rfc2087#section-4.3)
+    pub async fn get_quota_root(
+        &mut self,
+        mailbox_name: &str,
+    ) -> Result<(Vec<QuotaRoot>, Vec<Quota>)> {
+        let id = self
+            .run_command(format!("GETQUOTAROOT {}", quote!(mailbox_name)))
+            .await?;
+        let c = parse_get_quota_root(
+            &mut self.conn.stream,
+            self.unsolicited_responses_tx.clone(),
+            id,
+        )
+        .await?;
+        Ok(c)
+    }
+
     // these are only here because they are public interface, the rest is in `Connection`
     /// Runs a command and checks if it returns OK.
     pub async fn run_command_and_check_ok<S: AsRef<str>>(&mut self, command: S) -> Result<()> {

src/error.rs

@@ -55,6 +55,9 @@ pub enum ParseError {
     /// The client received data that was not UTF-8 encoded.
     #[error("unable to parse data ({0:?}) as UTF-8 text: {1:?}")]
     DataNotUtf8(Vec<u8>, #[source] Utf8Error),
+    /// The expected response for X was not found
+    #[error("expected response not found for: {0}")]
+    ExpectedResponseNotFound(String),
 }
 
 /// An [invalid character](https://tools.ietf.org/html/rfc3501#section-4.3) was found in an input

src/extensions/mod.rs

@@ -1,2 +1,4 @@
 //! Implementations of various IMAP extensions.
 pub mod idle;
+
+pub mod quota;

src/extensions/quota.rs

@@ -0,0 +1,75 @@
+//! Adds support for the GETQUOTA and GETQUOTAROOT commands specificed in [RFC2087](https://tools.ietf.org/html/rfc2087).
+
+use async_std::channel;
+use async_std::io;
+use async_std::prelude::*;
+use async_std::stream::Stream;
+use imap_proto::{self, RequestId, Response};
+
+use crate::types::*;
+use crate::{
+    error::Result,
+    parse::{filter_sync, handle_unilateral},
+};
+use crate::{
+    error::{Error, ParseError},
+    types::{Quota, QuotaRoot, ResponseData},
+};
+
+pub(crate) async fn parse_get_quota<T: Stream<Item = io::Result<ResponseData>> + Unpin>(
+    stream: &mut T,
+    unsolicited: channel::Sender<UnsolicitedResponse>,
+    command_tag: RequestId,
+) -> Result<Quota> {
+    let mut quota = None;
+    while let Some(resp) = stream
+        .take_while(|res| filter_sync(res, &command_tag))
+        .next()
+        .await
+    {
+        let resp = resp?;
+        match resp.parsed() {
+            Response::Quota(q) => quota = Some(q.clone().into()),
+            _ => {
+                handle_unilateral(resp, unsolicited.clone()).await;
+            }
+        }
+    }
+
+    match quota {
+        Some(q) => Ok(q),
+        None => Err(Error::Parse(ParseError::ExpectedResponseNotFound(
+            "Quota, no quota response found".to_string(),
+        ))),
+    }
+}
+
+pub(crate) async fn parse_get_quota_root<T: Stream<Item = io::Result<ResponseData>> + Unpin>(
+    stream: &mut T,
+    unsolicited: channel::Sender<UnsolicitedResponse>,
+    command_tag: RequestId,
+) -> Result<(Vec<QuotaRoot>, Vec<Quota>)> {
+    let mut roots: Vec<QuotaRoot> = Vec::new();
+    let mut quotas: Vec<Quota> = Vec::new();
+
+    while let Some(resp) = stream
+        .take_while(|res| filter_sync(res, &command_tag))
+        .next()
+        .await
+    {
+        let resp = resp?;
+        match resp.parsed() {
+            Response::QuotaRoot(qr) => {
+                roots.push(qr.clone().into());
+            }
+            Response::Quota(q) => {
+                quotas.push(q.clone().into());
+            }
+            _ => {
+                handle_unilateral(resp, unsolicited.clone()).await;
+            }
+        }
+    }
+
+    Ok((roots, quotas))
+}

src/parse.rs

@@ -46,7 +46,7 @@ fn filter(res: &io::Result<ResponseData>, command_tag: &RequestId) -> impl Futur
     futures::future::ready(val)
 }
 
-fn filter_sync(res: &io::Result<ResponseData>, command_tag: &RequestId) -> bool {
+pub(crate) fn filter_sync(res: &io::Result<ResponseData>, command_tag: &RequestId) -> bool {
     match res {
         Ok(res) => match res.parsed() {
             Response::Done { tag, .. } => tag != command_tag,

src/types/mod.rs

@@ -213,6 +213,9 @@ pub(crate) use self::response_data::ResponseData;
 mod request;
 pub(crate) use self::request::Request;
 
+mod quota;
+pub use self::quota::*;
+
 /// Responses that the server sends that are not related to the current command.
 /// [RFC 3501](https://tools.ietf.org/html/rfc3501#section-7) states that clients need to be able
 /// to accept any response at any time. These are the ones we've encountered in the wild.

src/types/quota.rs

@@ -0,0 +1,93 @@
+use imap_proto::types::Quota as QuotaRef;
+use imap_proto::types::QuotaResource as QuotaResourceRef;
+use imap_proto::types::QuotaResourceName as QuotaResourceNameRef;
+use imap_proto::types::QuotaRoot as QuotaRootRef;
+
+/// https://tools.ietf.org/html/rfc2087#section-3
+#[derive(Debug, Eq, PartialEq, Hash, Clone)]
+pub enum QuotaResourceName {
+    /// Sum of messages' RFC822.SIZE, in units of 1024 octets
+    Storage,
+    /// Number of messages
+    Message,
+    /// A different/custom resource
+    Atom(String),
+}
+
+impl<'a> From<QuotaResourceNameRef<'a>> for QuotaResourceName {
+    fn from(name: QuotaResourceNameRef<'_>) -> Self {
+        match name {
+            QuotaResourceNameRef::Message => QuotaResourceName::Message,
+            QuotaResourceNameRef::Storage => QuotaResourceName::Storage,
+            QuotaResourceNameRef::Atom(v) => QuotaResourceName::Atom(v.to_string()),
+        }
+    }
+}
+
+/// 5.1. QUOTA Response (https://tools.ietf.org/html/rfc2087#section-5.1)
+#[derive(Debug, Eq, PartialEq, Hash, Clone)]
+pub struct QuotaResource {
+    /// name of the resource
+    pub name: QuotaResourceName,
+    /// current usage of the resource
+    pub usage: u64,
+    /// resource limit
+    pub limit: u64,
+}
+
+impl<'a> From<QuotaResourceRef<'a>> for QuotaResource {
+    fn from(resource: QuotaResourceRef<'_>) -> Self {
+        Self {
+            name: resource.name.into(),
+            usage: resource.usage,
+            limit: resource.limit,
+        }
+    }
+}
+
+impl QuotaResource {
+    /// gets the usage percentage of a QuotaResource
+    pub fn get_usage_percentage(&self) -> u64 {
+        self.usage.saturating_mul(100) / self.limit
+    }
+}
+
+/// 5.1. QUOTA Response (https://tools.ietf.org/html/rfc2087#section-5.1)
+#[derive(Debug, Eq, PartialEq, Hash, Clone)]
+pub struct Quota {
+    /// quota root name
+    pub root_name: String,
+    /// quota resources for this quota
+    pub resources: Vec<QuotaResource>,
+}
+
+impl<'a> From<QuotaRef<'a>> for Quota {
+    fn from(quota: QuotaRef<'_>) -> Self {
+        Self {
+            root_name: quota.root_name.to_string(),
+            resources: quota.resources.iter().map(|r| r.clone().into()).collect(),
+        }
+    }
+}
+
+/// 5.2. QUOTAROOT Response (https://tools.ietf.org/html/rfc2087#section-5.2)
+#[derive(Debug, Eq, PartialEq, Hash, Clone)]
+pub struct QuotaRoot {
+    /// mailbox name
+    pub mailbox_name: String,
+    /// zero or more quota root names
+    pub quota_root_names: Vec<String>,
+}
+
+impl<'a> From<QuotaRootRef<'a>> for QuotaRoot {
+    fn from(root: QuotaRootRef<'_>) -> Self {
+        Self {
+            mailbox_name: root.mailbox_name.to_string(),
+            quota_root_names: root
+                .quota_root_names
+                .iter()
+                .map(|n| n.to_string())
+                .collect(),
+        }
+    }
+}