sander/rust-imap
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

changed try! to ?

Browse source
This commit is contained in:
Shaun Savage 2018-06-27 23:17:49 +00:00
parent 923e01279a
commit ba8afa7918
1 changed files with 27 additions and 27 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

54
src/client.rs
View file

@ -75,7 +75,7 @@ impl<'a, T: Read + Write + 'a> IdleHandle<'a, T> {
keepalive: Duration::from_secs(29 * 60), keepalive: Duration::from_secs(29 * 60),
done: false, done: false,
}; };
try!(h.init()); h.init()?;
Ok(h) Ok(h)
} }
@ -83,14 +83,14 @@ impl<'a, T: Read + Write + 'a> IdleHandle<'a, T> {
// https://tools.ietf.org/html/rfc2177 // https://tools.ietf.org/html/rfc2177
// //
// The IDLE command takes no arguments. // The IDLE command takes no arguments.
try!(self.client.run_command("IDLE")); self.client.run_command("IDLE")?;
// A tagged response will be sent either // A tagged response will be sent either
// //
// a) if there's an error, or // a) if there's an error, or
// b) *after* we send DONE // b) *after* we send DONE
let mut v = Vec::new(); let mut v = Vec::new();
try!(self.client.readline(&mut v)); self.client.readline(&mut v)?;
if v.starts_with(b"+") { if v.starts_with(b"+") {
self.done = false; self.done = false;
return Ok(()); return Ok(());
@ -104,7 +104,7 @@ impl<'a, T: Read + Write + 'a> IdleHandle<'a, T> {
fn terminate(&mut self) -> Result<()> { fn terminate(&mut self) -> Result<()> {
if !self.done { if !self.done {
self.done = true; self.done = true;
try!(self.client.write_line(b"DONE")); self.client.write_line(b"DONE")?;
self.client.read_response().map(|_| ()) self.client.read_response().map(|_| ())
} else { } else {
Ok(()) Ok(())
@ -121,8 +121,8 @@ impl<'a, T: Read + Write + 'a> IdleHandle<'a, T> {
if e.kind() == io::ErrorKind::TimedOut || e.kind() == io::ErrorKind::WouldBlock => if e.kind() == io::ErrorKind::TimedOut || e.kind() == io::ErrorKind::WouldBlock =>
{ {
// we need to refresh the IDLE connection // we need to refresh the IDLE connection
try!(self.terminate()); self.terminate()?;
try!(self.init()); self.init()?;
self.wait_inner() self.wait_inner()
} }
r => r, r => r,
@ -165,7 +165,7 @@ impl<'a, T: SetReadTimeout + Read + Write + 'a> IdleHandle<'a, T> {
/// Block until the selected mailbox changes, or until the given amount of time has expired. /// Block until the selected mailbox changes, or until the given amount of time has expired.
pub fn wait_timeout(mut self, timeout: Duration) -> Result<()> { pub fn wait_timeout(mut self, timeout: Duration) -> Result<()> {
try!(self.client.stream.get_mut().set_read_timeout(Some(timeout))); self.client.stream.get_mut().set_read_timeout(Some(timeout))?;
let res = self.wait_inner(); let res = self.wait_inner();
self.client.stream.get_mut().set_read_timeout(None).is_ok(); self.client.stream.get_mut().set_read_timeout(None).is_ok();
res res
@ -200,7 +200,7 @@ impl Client<TcpStream> {
Ok(stream) => { Ok(stream) => {
let mut socket = Client::new(stream); let mut socket = Client::new(stream);
try!(socket.read_greeting()); socket.read_greeting()?;
Ok(socket) Ok(socket)
} }
Err(e) => Err(Error::Io(e)), Err(e) => Err(Error::Io(e)),
@ -217,7 +217,7 @@ impl Client<TcpStream> {
) -> Result<Client<TlsStream<TcpStream>>> { ) -> Result<Client<TlsStream<TcpStream>>> {
// TODO This needs to be tested // TODO This needs to be tested
self.run_command_and_check_ok("STARTTLS")?; self.run_command_and_check_ok("STARTTLS")?;
TlsConnector::connect(ssl_connector, domain, try!(self.stream.into_inner())) TlsConnector::connect(ssl_connector, domain, self.stream.into_inner()?)
.map(Client::new) .map(Client::new)
.map_err(Error::TlsHandshake) .map_err(Error::TlsHandshake)
} }
@ -238,7 +238,7 @@ impl Client<TlsStream<TcpStream>> {
}; };
let mut socket = Client::new(ssl_stream); let mut socket = Client::new(ssl_stream);
try!(socket.read_greeting()); socket.read_greeting()?;
Ok(socket) Ok(socket)
} }
Err(e) => Err(Error::Io(e)), Err(e) => Err(Error::Io(e)),
@ -262,7 +262,7 @@ impl<T: Read + Write> Client<T> {
auth_type: &str, auth_type: &str,
authenticator: A, authenticator: A,
) -> Result<()> { ) -> Result<()> {
try!(self.run_command(&format!("AUTHENTICATE {}", auth_type))); self.run_command(&format!("AUTHENTICATE {}", auth_type))?;
self.do_auth_handshake(authenticator) self.do_auth_handshake(authenticator)
} }
@ -271,15 +271,15 @@ impl<T: Read + Write> Client<T> {
// TODO Clean up this code // TODO Clean up this code
loop { loop {
let mut line = Vec::new(); let mut line = Vec::new();
try!(self.readline(&mut line)); self.readline(&mut line)?;
if line.starts_with(b"+") { if line.starts_with(b"+") {
let data = try!(parse_authenticate_response( let data = parse_authenticate_response(
String::from_utf8(line).unwrap() String::from_utf8(line).unwrap()
)); )?;
let auth_response = authenticator.process(data); let auth_response = authenticator.process(data);
try!(self.write_line(auth_response.into_bytes().as_slice())) self.write_line(auth_response.into_bytes().as_slice())?
} else { } else {
return self.read_response_onto(&mut line).map(|_| ()); return self.read_response_onto(&mut line).map(|_| ());
} }
@ -447,15 +447,15 @@ impl<T: Read + Write> Client<T> {
/// The APPEND command adds a mail to a mailbox. /// The APPEND command adds a mail to a mailbox.
pub fn append(&mut self, folder: &str, content: &[u8]) -> Result<()> { pub fn append(&mut self, folder: &str, content: &[u8]) -> Result<()> {
try!(self.run_command(&format!("APPEND \"{}\" {{{}}}", folder, content.len()))); self.run_command(&format!("APPEND \"{}\" {{{}}}", folder, content.len()))?;
let mut v = Vec::new(); let mut v = Vec::new();
try!(self.readline(&mut v)); self.readline(&mut v)?;
if !v.starts_with(b"+") { if !v.starts_with(b"+") {
return Err(Error::Append); return Err(Error::Append);
} }
try!(self.stream.write_all(content)); self.stream.write_all(content)?;
try!(self.stream.write_all(b"\r\n")); self.stream.write_all(b"\r\n")?;
try!(self.stream.flush()); self.stream.flush()?;
self.read_response().map(|_| ()) self.read_response().map(|_| ())
} }
@ -471,7 +471,7 @@ impl<T: Read + Write> Client<T> {
} }
pub fn run_command_and_read_response(&mut self, untagged_command: &str) -> Result<Vec<u8>> { pub fn run_command_and_read_response(&mut self, untagged_command: &str) -> Result<Vec<u8>> {
try!(self.run_command(untagged_command)); self.run_command(untagged_command)?;
self.read_response() self.read_response()
} }
@ -491,7 +491,7 @@ impl<T: Read + Write> Client<T> {
0 0
} else { } else {
let start_new = data.len(); let start_new = data.len();
try!(self.readline(data)); self.readline(data)?;
continue_from.take().unwrap_or(start_new) continue_from.take().unwrap_or(start_new)
}; };
@ -555,13 +555,13 @@ impl<T: Read + Write> Client<T> {
fn read_greeting(&mut self) -> Result<()> { fn read_greeting(&mut self) -> Result<()> {
let mut v = Vec::new(); let mut v = Vec::new();
try!(self.readline(&mut v)); self.readline(&mut v)?;
Ok(()) Ok(())
} }
fn readline(&mut self, into: &mut Vec<u8>) -> Result<usize> { fn readline(&mut self, into: &mut Vec<u8>) -> Result<usize> {
use std::io::BufRead; use std::io::BufRead;
let read = try!(self.stream.read_until(LF, into)); let read = self.stream.read_until(LF, into)?;
if read == 0 { if read == 0 {
return Err(Error::ConnectionLost); return Err(Error::ConnectionLost);
} }
@ -583,9 +583,9 @@ impl<T: Read + Write> Client<T> {
} }
fn write_line(&mut self, buf: &[u8]) -> Result<()> { fn write_line(&mut self, buf: &[u8]) -> Result<()> {
try!(self.stream.write_all(buf)); self.stream.write_all(buf)?;
try!(self.stream.write_all(&[CR, LF])); self.stream.write_all(&[CR, LF])?;
try!(self.stream.flush()); self.stream.flush()?;
if self.debug { if self.debug {
print!("C: {}\n", String::from_utf8(buf.to_vec()).unwrap()); print!("C: {}\n", String::from_utf8(buf.to_vec()).unwrap());
} }