diff --git a/src/lib.rs b/src/lib.rs index 11a1875..a7e6612 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -12,7 +12,7 @@ //! //! * 8BITMIME ([RFC 6152](https://tools.ietf.org/html/rfc6152)) //! * AUTH ([RFC 4954](http://tools.ietf.org/html/rfc4954)) with PLAIN and -//! CRAM-MD5 mecanisms +//! CRAM-MD5 mechanisms //! * STARTTLS ([RFC 2487](http://tools.ietf.org/html/rfc2487)) //! * SMTPUTF8 ([RFC 6531](http://tools.ietf.org/html/rfc6531)) //! @@ -60,7 +60,7 @@ //! use lettre::email::EmailBuilder; //! use lettre::transport::smtp::{SecurityLevel, SmtpTransport, //! SmtpTransportBuilder}; -//! use lettre::transport::smtp::authentication::Mecanism; +//! use lettre::transport::smtp::authentication::Mechanism; //! use lettre::transport::smtp::SUBMISSION_PORT; //! use lettre::transport::EmailTransport; //! @@ -89,8 +89,8 @@ //! .security_level(SecurityLevel::AlwaysEncrypt) //! // Enable SMTPUTF8 is the server supports it //! .smtp_utf8(true) -//! // Configure accepted authetication mecanisms -//! .authentication_mecanisms(vec![Mecanism::CramMd5]) +//! // Configure accepted authetication mechanisms +//! .authentication_mechanisms(vec![Mechanism::CramMd5]) //! // Enable connection reuse //! .connection_reuse(true).build(); //! diff --git a/src/transport/smtp/authentication.rs b/src/transport/smtp/authentication.rs index cdf37e8..a59eeaf 100644 --- a/src/transport/smtp/authentication.rs +++ b/src/transport/smtp/authentication.rs @@ -1,4 +1,4 @@ -//! Provides authentication mecanisms +//! Provides authentication mechanisms use std::fmt; use std::fmt::{Display, Formatter}; @@ -12,34 +12,34 @@ use crypto::mac::Mac; use transport::smtp::NUL; use transport::error::Error; -/// Represents authentication mecanisms +/// Represents authentication mechanisms #[derive(PartialEq,Eq,Copy,Clone,Hash,Debug)] -pub enum Mecanism { - /// PLAIN authentication mecanism +pub enum Mechanism { + /// PLAIN authentication mechanism /// RFC 4616: https://tools.ietf.org/html/rfc4616 Plain, - /// CRAM-MD5 authentication mecanism + /// CRAM-MD5 authentication mechanism /// RFC 2195: https://tools.ietf.org/html/rfc2195 CramMd5, } -impl Display for Mecanism { +impl Display for Mechanism { fn fmt(&self, f: &mut Formatter) -> fmt::Result { write!(f, "{}", match *self { - Mecanism::Plain => "PLAIN", - Mecanism::CramMd5 => "CRAM-MD5", + Mechanism::Plain => "PLAIN", + Mechanism::CramMd5 => "CRAM-MD5", }) } } -impl Mecanism { - /// Does the mecanism supports initial response +impl Mechanism { + /// Does the mechanism supports initial response pub fn supports_initial_response(&self) -> bool { match *self { - Mecanism::Plain => true, - Mecanism::CramMd5 => false, + Mechanism::Plain => true, + Mechanism::CramMd5 => false, } } @@ -51,18 +51,18 @@ impl Mecanism { challenge: Option<&str>) -> Result { match *self { - Mecanism::Plain => { + Mechanism::Plain => { match challenge { - Some(_) => Err(Error::ClientError("This mecanism does not expect a challenge")), + Some(_) => Err(Error::ClientError("This mechanism does not expect a challenge")), None => Ok(format!("{}{}{}{}", NUL, username, NUL, password) .as_bytes() .to_base64(base64::STANDARD)), } } - Mecanism::CramMd5 => { + Mechanism::CramMd5 => { let encoded_challenge = match challenge { Some(challenge) => challenge, - None => return Err(Error::ClientError("This mecanism does expect a challenge")), + None => return Err(Error::ClientError("This mechanism does expect a challenge")), }; let decoded_challenge = match encoded_challenge.from_base64() { @@ -83,27 +83,27 @@ impl Mecanism { #[cfg(test)] mod test { - use super::Mecanism; + use super::Mechanism; #[test] fn test_plain() { - let mecanism = Mecanism::Plain; + let mechanism = Mechanism::Plain; - assert_eq!(mecanism.response("username", "password", None).unwrap(), + assert_eq!(mechanism.response("username", "password", None).unwrap(), "AHVzZXJuYW1lAHBhc3N3b3Jk"); - assert!(mecanism.response("username", "password", Some("test")).is_err()); + assert!(mechanism.response("username", "password", Some("test")).is_err()); } #[test] fn test_cram_md5() { - let mecanism = Mecanism::CramMd5; + let mechanism = Mechanism::CramMd5; - assert_eq!(mecanism.response("alice", + assert_eq!(mechanism.response("alice", "wonderland", Some("PDE3ODkzLjEzMjA2NzkxMjNAdGVzc2VyYWN0LnN1c2FtLmluPg==")) .unwrap(), "YWxpY2UgNjRiMmE0M2MxZjZlZDY4MDZhOTgwOTE0ZTIzZTc1ZjA="); - assert!(mecanism.response("alice", "wonderland", Some("tést")).is_err()); - assert!(mecanism.response("alice", "wonderland", None).is_err()); + assert!(mechanism.response("alice", "wonderland", Some("tést")).is_err()); + assert!(mechanism.response("alice", "wonderland", None).is_err()); } } diff --git a/src/transport/smtp/client/mod.rs b/src/transport/smtp/client/mod.rs index d70b78f..febbb9d 100644 --- a/src/transport/smtp/client/mod.rs +++ b/src/transport/smtp/client/mod.rs @@ -11,7 +11,7 @@ use openssl::ssl::SslContext; use transport::error::{EmailResult, Error}; use transport::smtp::response::ResponseParser; -use transport::smtp::authentication::Mecanism; +use transport::smtp::authentication::Mechanism; use transport::smtp::client::net::{Connector, NetworkStream}; use transport::smtp::{CRLF, MESSAGE_ENDING}; @@ -173,13 +173,13 @@ impl Client { self.command("RSET") } - /// Sends an AUTH command with the given mecanism - pub fn auth(&mut self, mecanism: Mecanism, username: &str, password: &str) -> EmailResult { + /// Sends an AUTH command with the given mechanism + pub fn auth(&mut self, mechanism: Mechanism, username: &str, password: &str) -> EmailResult { - if mecanism.supports_initial_response() { + if mechanism.supports_initial_response() { self.command(&format!("AUTH {} {}", - mecanism, - try!(mecanism.response(username, password, None)))) + mechanism, + try!(mechanism.response(username, password, None)))) } else { let encoded_challenge = match try!(self.command("AUTH CRAM-MD5")).first_word() { Some(challenge) => challenge, @@ -188,7 +188,7 @@ impl Client { debug!("CRAM challenge: {}", encoded_challenge); - let cram_response = try!(mecanism.response(username, + let cram_response = try!(mechanism.response(username, password, Some(&encoded_challenge))); diff --git a/src/transport/smtp/extension.rs b/src/transport/smtp/extension.rs index be09906..a1e2289 100644 --- a/src/transport/smtp/extension.rs +++ b/src/transport/smtp/extension.rs @@ -7,7 +7,7 @@ use std::collections::HashSet; use transport::error::Error; use transport::smtp::response::Response; -use transport::smtp::authentication::Mecanism; +use transport::smtp::authentication::Mechanism; /// Supported ESMTP keywords #[derive(PartialEq,Eq,Hash,Clone,Debug)] @@ -24,8 +24,8 @@ pub enum Extension { /// /// RFC 2487: https://tools.ietf.org/html/rfc2487 StartTls, - /// AUTH mecanism - Authentication(Mecanism), + /// AUTH mechanism + Authentication(Mechanism), } impl Display for Extension { @@ -34,7 +34,7 @@ impl Display for Extension { Extension::EightBitMime => write!(f, "{}", "8BITMIME"), Extension::SmtpUtfEight => write!(f, "{}", "SMTPUTF8"), Extension::StartTls => write!(f, "{}", "STARTTLS"), - Extension::Authentication(ref mecanism) => write!(f, "{} {}", "AUTH", mecanism), + Extension::Authentication(ref mechanism) => write!(f, "{} {}", "AUTH", mechanism), } } } @@ -88,13 +88,13 @@ impl ServerInfo { features.insert(Extension::StartTls); } "AUTH" => { - for &mecanism in &splitted[1..] { - match mecanism { + for &mechanism in &splitted[1..] { + match mechanism { "PLAIN" => { - features.insert(Extension::Authentication(Mecanism::Plain)); + features.insert(Extension::Authentication(Mechanism::Plain)); } "CRAM-MD5" => { - features.insert(Extension::Authentication(Mecanism::CramMd5)); + features.insert(Extension::Authentication(Mechanism::CramMd5)); } _ => (), } @@ -116,8 +116,8 @@ impl ServerInfo { } /// Checks if the server supports an ESMTP feature - pub fn supports_auth_mecanism(&self, mecanism: Mecanism) -> bool { - self.features.contains(&Extension::Authentication(mecanism)) + pub fn supports_auth_mechanism(&self, mechanism: Mechanism) -> bool { + self.features.contains(&Extension::Authentication(mechanism)) } } @@ -126,14 +126,14 @@ mod test { use std::collections::HashSet; use super::{Extension, ServerInfo}; - use transport::smtp::authentication::Mecanism; + use transport::smtp::authentication::Mechanism; use transport::smtp::response::{Category, Code, Response, Severity}; #[test] fn test_extension_fmt() { assert_eq!(format!("{}", Extension::EightBitMime), "8BITMIME".to_string()); - assert_eq!(format!("{}", Extension::Authentication(Mecanism::Plain)), + assert_eq!(format!("{}", Extension::Authentication(Mechanism::Plain)), "AUTH PLAIN".to_string()); } @@ -159,7 +159,7 @@ mod test { "name with no supported features".to_string()); let mut plain = HashSet::new(); - assert!(plain.insert(Extension::Authentication(Mecanism::Plain))); + assert!(plain.insert(Extension::Authentication(Mechanism::Plain))); assert_eq!(format!("{}", ServerInfo { @@ -190,7 +190,7 @@ mod test { assert!(server_info.supports_feature(&Extension::EightBitMime)); assert!(!server_info.supports_feature(&Extension::StartTls)); - assert!(!server_info.supports_auth_mecanism(Mecanism::CramMd5)); + assert!(!server_info.supports_auth_mechanism(Mechanism::CramMd5)); let response2 = Response::new(Code::new(Severity::PositiveCompletion, Category::Unspecified4, @@ -202,8 +202,8 @@ mod test { let mut features2 = HashSet::new(); assert!(features2.insert(Extension::EightBitMime)); - assert!(features2.insert(Extension::Authentication(Mecanism::Plain))); - assert!(features2.insert(Extension::Authentication(Mecanism::CramMd5))); + assert!(features2.insert(Extension::Authentication(Mechanism::Plain))); + assert!(features2.insert(Extension::Authentication(Mechanism::CramMd5))); let server_info2 = ServerInfo { name: "me".to_string(), @@ -213,8 +213,8 @@ mod test { assert_eq!(ServerInfo::from_response(&response2).unwrap(), server_info2); assert!(server_info2.supports_feature(&Extension::EightBitMime)); - assert!(server_info2.supports_auth_mecanism(Mecanism::Plain)); - assert!(server_info2.supports_auth_mecanism(Mecanism::CramMd5)); + assert!(server_info2.supports_auth_mechanism(Mechanism::Plain)); + assert!(server_info2.supports_auth_mechanism(Mechanism::CramMd5)); assert!(!server_info2.supports_feature(&Extension::StartTls)); } } diff --git a/src/transport/smtp/mod.rs b/src/transport/smtp/mod.rs index 24e7fb7..c658511 100644 --- a/src/transport/smtp/mod.rs +++ b/src/transport/smtp/mod.rs @@ -8,7 +8,7 @@ use openssl::ssl::{SslContext, SslMethod}; use transport::error::{EmailResult, Error}; use transport::smtp::extension::{Extension, ServerInfo}; use transport::smtp::client::Client; -use transport::smtp::authentication::Mecanism; +use transport::smtp::authentication::Mechanism; use transport::EmailTransport; use email::SendableEmail; @@ -75,8 +75,8 @@ pub struct SmtpTransportBuilder { security_level: SecurityLevel, /// Enable UTF8 mailboxes in enveloppe or headers smtp_utf8: bool, - /// List of authentication mecanism, sorted by priority - authentication_mecanisms: Vec, + /// List of authentication mechanism, sorted by priority + authentication_mechanisms: Vec, } /// Builder for the SMTP SmtpTransport @@ -95,7 +95,7 @@ impl SmtpTransportBuilder { connection_reuse_count_limit: 100, connection_reuse: false, hello_name: "localhost".to_string(), - authentication_mecanisms: vec![Mecanism::CramMd5, Mecanism::Plain], + authentication_mechanisms: vec![Mechanism::CramMd5, Mechanism::Plain], }), None => Err(From::from("Could nor resolve hostname")), } @@ -148,9 +148,9 @@ impl SmtpTransportBuilder { self } - /// Set the authentication mecanisms - pub fn authentication_mecanisms(mut self, mecanisms: Vec) -> SmtpTransportBuilder { - self.authentication_mecanisms = mecanisms; + /// Set the authentication mechanisms + pub fn authentication_mechanisms(mut self, mechanisms: Vec) -> SmtpTransportBuilder { + self.authentication_mechanisms = mechanisms; self } @@ -293,16 +293,16 @@ impl EmailTransport for SmtpTransport { let mut found = false; - for mecanism in self.client_info.authentication_mecanisms.clone() { - if self.server_info.as_ref().unwrap().supports_auth_mecanism(mecanism) { + for mechanism in self.client_info.authentication_mechanisms.clone() { + if self.server_info.as_ref().unwrap().supports_auth_mechanism(mechanism) { found = true; - try_smtp!(self.client.auth(mecanism, &username, &password), self); + try_smtp!(self.client.auth(mechanism, &username, &password), self); break; } } if !found { - info!("No supported authentication mecanisms available"); + info!("No supported authentication mechanisms available"); } } }