rust/lettre
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

rustfmt pass

Browse Source
This commit is contained in:
Alexis Mousset
2016-03-20 01:21:15 +01:00
parent af20cfa8ff
commit f8c883f58e
5 changed files with 72 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
Cargo.toml
View File

@@ -11,17 +11,17 @@ authors = ["Alexis Mousset <contact@amousset.me>"]
keywords = ["email", "smtp", "mailer"]
[dependencies]
time = "0.1"
uuid = "0.1"
log = "0.3"
rustc-serialize = "0.3"
rust-crypto = "0.2"
bufstream = "0.1"
email = "0.0"
log = "0.3"
openssl = "0.7"
rustc-serialize = "0.3"
rust-crypto = "0.2"
time = "0.1"
uuid = "0.1"
[dev-dependencies]
env_logger = "0.3"
[features]
unstable = []
unstable = []

18
src/transport/smtp/authentication.rs
View File

@@ -53,18 +53,22 @@ impl Mechanism {
match *self {
Mechanism::Plain => {
match 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)),
Some(_) => {
Err(Error::ClientError("This mechanism does not expect a challenge"))
}
None => {
Ok(format!("{}{}{}{}", NUL, username, NUL, password)
.as_bytes()
.to_base64(base64::STANDARD))
}
}
}
Mechanism::CramMd5 => {
let encoded_challenge = match challenge {
Some(challenge) => challenge,
None =>
return Err(Error::ClientError("This mechanism does expect a challenge")),
None => {
return Err(Error::ClientError("This mechanism does expect a challenge"))
}
};
let decoded_challenge = match encoded_challenge.from_base64() {

20
src/transport/smtp/client/net.rs
View File

@@ -21,20 +21,24 @@ impl Connector for NetworkStream {
let tcp_stream = try!(TcpStream::connect(addr));
match ssl_context {
Some(context) => match SslStream::connect_generic(context, tcp_stream) {
Ok(stream) => Ok(NetworkStream::Ssl(stream)),
Err(err) => Err(io::Error::new(ErrorKind::Other, err)),
},
Some(context) => {
match SslStream::connect_generic(context, tcp_stream) {
Ok(stream) => Ok(NetworkStream::Ssl(stream)),
Err(err) => Err(io::Error::new(ErrorKind::Other, err)),
}
}
None => Ok(NetworkStream::Plain(tcp_stream)),
}
}
fn upgrade_tls(&mut self, ssl_context: &SslContext) -> io::Result<()> {
*self = match self.clone() {
NetworkStream::Plain(stream) => match SslStream::connect_generic(ssl_context, stream) {
Ok(ssl_stream) => NetworkStream::Ssl(ssl_stream),
Err(err) => return Err(io::Error::new(ErrorKind::Other, err)),
},
NetworkStream::Plain(stream) => {
match SslStream::connect_generic(ssl_context, stream) {
Ok(ssl_stream) => NetworkStream::Ssl(ssl_stream),
Err(err) => return Err(io::Error::new(ErrorKind::Other, err)),
}
}
NetworkStream::Ssl(stream) => NetworkStream::Ssl(stream),
};
Ok(())

48
src/transport/smtp/mod.rs
View File

@@ -22,27 +22,27 @@ pub mod client;
// org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml
/// Default smtp port
pub static SMTP_PORT: u16 = 25;
pub const SMTP_PORT: u16 = 25;
/// Default submission port
pub static SUBMISSION_PORT: u16 = 587;
pub const SUBMISSION_PORT: u16 = 587;
// Useful strings and characters
/// The word separator for SMTP transactions
pub static SP: &'static str = " ";
pub const SP: &'static str = " ";
/// The line ending for SMTP transactions (carriage return + line feed)
pub static CRLF: &'static str = "\r\n";
pub const CRLF: &'static str = "\r\n";
/// Colon
pub static COLON: &'static str = ":";
pub const COLON: &'static str = ":";
/// The ending of message content
pub static MESSAGE_ENDING: &'static str = "\r\n.\r\n";
pub const MESSAGE_ENDING: &'static str = "\r\n.\r\n";
/// NUL unicode character
pub static NUL: &'static str = "\0";
pub const NUL: &'static str = "\0";
/// TLS security level
#[derive(Debug)]
@@ -94,17 +94,19 @@ impl SmtpTransportBuilder {
let mut addresses = try!(addr.to_socket_addrs());
match addresses.next() {
Some(addr) => Ok(SmtpTransportBuilder {
server_addr: addr,
ssl_context: SslContext::new(SslMethod::Tlsv1).unwrap(),
security_level: SecurityLevel::Opportunistic,
smtp_utf8: false,
credentials: None,
connection_reuse_count_limit: 100,
connection_reuse: false,
hello_name: "localhost".to_string(),
authentication_mechanisms: vec![Mechanism::CramMd5, Mechanism::Plain],
}),
Some(addr) => {
Ok(SmtpTransportBuilder {
server_addr: addr,
ssl_context: SslContext::new(SslMethod::Tlsv1).unwrap(),
security_level: SecurityLevel::Opportunistic,
smtp_utf8: false,
credentials: None,
connection_reuse_count_limit: 100,
connection_reuse: false,
hello_name: "localhost".to_string(),
authentication_mechanisms: vec![Mechanism::CramMd5, Mechanism::Plain],
})
}
None => Err(From::from("Could nor resolve hostname")),
}
}
@@ -287,8 +289,9 @@ impl EmailTransport for SmtpTransport {
if self.state.connection_reuse_count == 0 {
try!(self.client.connect(&self.client_info.server_addr,
match &self.client_info.security_level {
&SecurityLevel::EncryptedWrapper =>
Some(&self.client_info.ssl_context),
&SecurityLevel::EncryptedWrapper => {
Some(&self.client_info.ssl_context)
}
_ => None,
}));
@@ -299,8 +302,9 @@ impl EmailTransport for SmtpTransport {
match (&self.client_info.security_level,
self.server_info.as_ref().unwrap().supports_feature(&Extension::StartTls)) {
(&SecurityLevel::AlwaysEncrypt, false) =>
return Err(From::from("Could not encrypt connection, aborting")),
(&SecurityLevel::AlwaysEncrypt, false) => {
return Err(From::from("Could not encrypt connection, aborting"))
}
(&SecurityLevel::Opportunistic, false) => (),
(&SecurityLevel::NeverEncrypt, _) => (),
(&SecurityLevel::EncryptedWrapper, _) => (),

28
src/transport/smtp/response.rs
View File

@@ -115,11 +115,13 @@ impl FromStr for Code {
match (s[0..1].parse::<Severity>(),
s[1..2].parse::<Category>(),
s[2..3].parse::<u8>()) {
(Ok(severity), Ok(category), Ok(detail)) => Ok(Code {
severity: severity,
category: category,
detail: detail,
}),
(Ok(severity), Ok(category), Ok(detail)) => {
Ok(Code {
severity: severity,
category: category,
detail: detail,
})
}
_ => return Err(Error::ResponseParsingError("Could not parse response code")),
}
} else {
@@ -196,8 +198,10 @@ impl ResponseParser {
pub fn response(self) -> EmailResult {
match self.code {
Some(code) => Ok(Response::new(code, self.message)),
None => Err(Error::ResponseParsingError("Incomplete response, could not read \
response code")),
None => {
Err(Error::ResponseParsingError("Incomplete response, could not read response \
code"))
}
}
}
}
@@ -266,10 +270,12 @@ impl Response {
pub fn first_word(&self) -> Option<String> {
match self.message.is_empty() {
true => None,
false => match self.message[0].split_whitespace().next() {
Some(word) => Some(word.to_string()),
None => None,
},
false => {
match self.message[0].split_whitespace().next() {
Some(word) => Some(word.to_string()),
None => None,
}
}
}
}
}