Make rsasl optional

Author: dequbed

Cargo.toml

@@ -26,7 +26,7 @@ regex = "1.0"
 bufstream = "0.1.3"
 imap-proto = "0.16.1"
 nom = { version = "7.1.0", default-features = false }
-rsasl = { version = "2.0.0-rc.2", default-features = false, features = ["provider_base64"] }
+rsasl = { version = "2.0.0-rc.2", default-features = false, features = ["provider_base64"], optional = true }
 base64 = "0.13.0"
 chrono = { version = "0.4", default-features = false, features = ["std"]}
 lazy_static = "1.4"
@@ -74,4 +74,4 @@ required-features = ["default"]
 
 [[example]]
 name = "rustls_sasl"
-required-features = ["rustls-tls"]
+required-features = ["rustls-tls", "rsasl"]

src/client.rs

@@ -6,7 +6,8 @@ use std::io::{Read, Write};
 use std::ops::{Deref, DerefMut};
 use std::str;
 use std::sync::mpsc;
-use std::sync::Arc;
+
+#[cfg(feature = "rsasl")]
 use rsasl::prelude::{Mechname, SASLClient, SASLConfig, Session as SASLSession, State as SASLState};
 
 use super::authenticator::Authenticator;
@@ -361,7 +362,7 @@ impl<T: Read + Write> Client<T> {
     /// match client.login("user", "pass") {
     ///     Ok(s) => {
     ///         // you are successfully authenticated!
-    ///     },
+    ///     }
     ///     Err((e, orig_client)) => {
     ///         eprintln!("error logging in: {}", e);
     ///         // prompt user and try again with orig_client here
@@ -419,7 +420,7 @@ impl<T: Read + Write> Client<T> {
     ///     match client.authenticate("XOAUTH2", &auth) {
     ///         Ok(session) => {
     ///             // you are successfully authenticated!
-    ///         },
+    ///         }
     ///         Err((e, orig_client)) => {
     ///             eprintln!("error authenticating: {}", e);
     ///             // prompt user and try again with orig_client here
@@ -428,9 +429,82 @@ impl<T: Read + Write> Client<T> {
     ///     };
     /// }
     /// ```
-    pub fn authenticate(
+    pub fn authenticate<A: Authenticator>(
         mut self,
-        config: Arc<SASLConfig>,
+        auth_type: impl AsRef<str>,
+        authenticator: &A,
+    ) -> ::std::result::Result<Session<T>, (Error, Client<T>)> {
+        ok_or_unauth_client_err!(
+            self.run_command(&format!("AUTHENTICATE {}", auth_type.as_ref())),
+            self
+        );
+        self.do_auth_handshake(authenticator)
+    }
+
+    /// This func does the handshake process once the authenticate command is made.
+    fn do_auth_handshake<A: Authenticator>(
+        mut self,
+        authenticator: &A,
+    ) -> ::std::result::Result<Session<T>, (Error, Client<T>)> {
+        // TODO Clean up this code
+        loop {
+            let mut line = Vec::new();
+
+            // explicit match blocks neccessary to convert error to tuple and not bind self too
+            // early (see also comment on `login`)
+            ok_or_unauth_client_err!(self.readline(&mut line), self);
+
+            // ignore server comments
+            if line.starts_with(b"* ") {
+                continue;
+            }
+
+            // Some servers will only send `+\r\n`.
+            if line.starts_with(b"+ ") || &line == b"+\r\n" {
+                let challenge = if &line == b"+\r\n" {
+                    Vec::new()
+                } else {
+                    let line_str = ok_or_unauth_client_err!(
+                        match str::from_utf8(line.as_slice()) {
+                            Ok(line_str) => Ok(line_str),
+                            Err(e) => Err(Error::Parse(ParseError::DataNotUtf8(line, e))),
+                        },
+                        self
+                    );
+                    let data =
+                        ok_or_unauth_client_err!(parse_authenticate_response(line_str), self);
+                    ok_or_unauth_client_err!(
+                        base64::decode(data).map_err(|e| Error::Parse(ParseError::Authentication(
+                            data.to_string(),
+                            Some(e)
+                        ))),
+                        self
+                    )
+                };
+
+                let raw_response = &authenticator.process(&challenge);
+                let auth_response = base64::encode(raw_response);
+                ok_or_unauth_client_err!(
+                    self.write_line(auth_response.into_bytes().as_slice()),
+                    self
+                );
+            } else {
+                ok_or_unauth_client_err!(self.read_response_onto(&mut line), self);
+                return Ok(Session::new(self.conn));
+            }
+        }
+    }
+}
+
+#[cfg(feature = "rsasl")]
+impl<T: Read + Write> Client<T> {
+
+    /// Authenticate with the server using the given custom SASLConfig to handle the server's
+    /// challenge.
+    ///
+    pub fn sasl_auth(
+        mut self,
+        config: ::std::sync::Arc<SASLConfig>,
         mechanism: &Mechname,
     ) -> ::std::result::Result<Session<T>, (Error, Client<T>)> {
         let client = SASLClient::new(config);
@@ -444,11 +518,11 @@ impl<T: Read + Write> Client<T> {
             self.run_command(&format!("AUTHENTICATE {}", mechanism.as_str())),
             self
         );
-        self.do_auth_handshake(session)
+        self.do_sasl_handshake(session)
     }
 
-    /// This func does the handshake process once the authenticate command is made.
-    fn do_auth_handshake(
+    /// This func does the SASL handshake process once the authenticate command is made.
+    fn do_sasl_handshake(
         mut self,
         mut authenticator: SASLSession,
     ) -> ::std::result::Result<Session<T>, (Error, Client<T>)> {

src/error.rs

@@ -14,6 +14,7 @@ use imap_proto::{types::ResponseCode, Response};
 use native_tls::Error as TlsError;
 #[cfg(feature = "native-tls")]
 use native_tls::HandshakeError as TlsHandshakeError;
+#[cfg(feature = "rsasl")]
 use rsasl::prelude::{SASLError, SessionError as SASLSessionError};
 #[cfg(feature = "rustls-tls")]
 use rustls_connector::HandshakeError as RustlsHandshakeError;
@@ -93,9 +94,11 @@ pub enum Error {
     ConnectionLost,
     /// Error parsing a server response.
     Parse(ParseError),
+    #[cfg(feature = "rsasl")]
     /// Error occurred when tyring to set up authentication
     AuthenticationSetup(SASLError),
     /// Error occurred during authentication
+    #[cfg(feature = "rsasl")]
     Authentication(SASLSessionError),
     /// Command inputs were not valid [IMAP
     /// strings](https://tools.ietf.org/html/rfc3501#section-4.3).
@@ -123,11 +126,13 @@ impl From<ParseError> for Error {
     }
 }
 
+#[cfg(feature = "rsasl")]
 impl From<SASLError> for Error {
     fn from(err: SASLError) -> Self {
         Error::AuthenticationSetup(err)
     }
 }
+#[cfg(feature = "rsasl")]
 impl From<SASLSessionError> for Error {
     fn from(err: SASLSessionError) -> Self {
         Error::Authentication(err)
@@ -186,7 +191,9 @@ impl fmt::Display for Error {
             Error::Append => f.write_str("Could not append mail to mailbox"),
             Error::Unexpected(ref r) => write!(f, "Unexpected Response: {:?}", r),
             Error::MissingStatusResponse => write!(f, "Missing STATUS Response"),
+            #[cfg(feature = "rsasl")]
             Error::AuthenticationSetup(ref e) => fmt::Display::fmt(e, f),
+            #[cfg(feature = "rsasl")]
             Error::Authentication(ref e) => fmt::Display::fmt(e, f),
         }
     }
@@ -212,7 +219,9 @@ impl StdError for Error {
             Error::Append => "Could not append mail to mailbox",
             Error::Unexpected(_) => "Unexpected Response",
             Error::MissingStatusResponse => "Missing STATUS Response",
+            #[cfg(feature = "rsasl")]
             Error::AuthenticationSetup(_) => "Failed to setup authentication",
+            #[cfg(feature = "rsasl")]
             Error::Authentication(_) => "Authentication Failed",
         }
     }
@@ -227,7 +236,9 @@ impl StdError for Error {
             #[cfg(feature = "native-tls")]
             Error::TlsHandshake(ref e) => Some(e),
             Error::Parse(ParseError::DataNotUtf8(_, ref e)) => Some(e),
+            #[cfg(feature = "rsasl")]
             Error::AuthenticationSetup(ref e) => Some(e),
+            #[cfg(feature = "rsasl")]
             Error::Authentication(ref e) => Some(e),
             _ => None,
         }