add quota support

Author: Simon-Laux

src/client.rs

@@ -1,21 +1,22 @@
-use std::collections::HashSet;
 use std::fmt;
 use std::ops::{Deref, DerefMut};
 use std::pin::Pin;
 use std::str;
+use std::{borrow::Cow, collections::HashSet};
 
 use async_native_tls::{TlsConnector, TlsStream};
 use async_std::channel;
 use async_std::io::{self, Read, Write};
 use async_std::net::{TcpStream, ToSocketAddrs};
 use async_std::prelude::*;
-use imap_proto::{RequestId, Response};
+use extensions::quota::parse_get_quota_root;
+use imap_proto::{Quota, QuotaRoot, 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: Cow<'_, 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: Cow<'_, 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/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,68 @@
+//! 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, Quota, QuotaRoot, RequestId, Response};
+
+use crate::types::ResponseData;
+use crate::types::*;
+use crate::{
+    error::Result,
+    parse::{filter_sync, handle_unilateral},
+};
+
+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<'_>> {
+    while let Some(resp) = stream
+        .take_while(|res| filter_sync(res, &command_tag))
+        .next()
+        .await
+    {
+        let resp = resp?;
+        match resp.parsed() {
+            Response::Quota(q) => {
+                return Ok(q.clone().into_owned());
+            }
+            _ => {
+                handle_unilateral(resp, unsolicited.clone()).await;
+            }
+        }
+    }
+
+    unreachable!(); // TODO, make this better
+}
+
+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_owned());
+            }
+            Response::Quota(q) => {
+                quotas.push(q.clone().into_owned());
+            }
+            _ => {
+                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,