xmppftw/xmpp-rs
Watch
1
0
Fork
You've already forked xmpp-rs
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

improve style

Browse source
This commit is contained in:
Astro 2018-09-06 23:57:42 +02:00
commit f4007511ea
7 changed files with 37 additions and 108 deletions
Download patch file Download diff file Expand all files Collapse all files

37
src/client/auth.rs
View file

@ -40,33 +40,26 @@ impl<S: AsyncWrite> ClientAuth<S> {
]; ];
let mech_names: Vec<String> = let mech_names: Vec<String> =
match stream.stream_features.get_child("mechanisms", NS_XMPP_SASL) { stream.stream_features.get_child("mechanisms", NS_XMPP_SASL)
None => .ok_or(AuthError::NoMechanism)?
return Err(AuthError::NoMechanism.into()), .children()
Some(mechs) => .filter(|child| child.is("mechanism", NS_XMPP_SASL))
mechs.children() .map(|mech_el| mech_el.text())
.filter(|child| child.is("mechanism", NS_XMPP_SASL)) .collect();
.map(|mech_el| mech_el.text())
.collect(),
};
// println!("SASL mechanisms offered: {:?}", mech_names); // println!("SASL mechanisms offered: {:?}", mech_names);
for mut mech in mechs { for mut mech in mechs {
let name = mech.name().to_owned(); let name = mech.name().to_owned();
if mech_names.iter().any(|name1| *name1 == name) { if mech_names.iter().any(|name1| *name1 == name) {
// println!("SASL mechanism selected: {:?}", name); // println!("SASL mechanism selected: {:?}", name);
let initial = match mech.initial() { let initial = mech.initial()
Ok(initial) => initial, .map_err(AuthError::Sasl)?;
Err(e) => return Err(AuthError::Sasl(e).into()),
};
let mut this = ClientAuth { let mut this = ClientAuth {
state: ClientAuthState::Invalid, state: ClientAuthState::Invalid,
mechanism: mech, mechanism: mech,
}; };
let mechanism = match XMPPMechanism::from_str(&name) { let mechanism = XMPPMechanism::from_str(&name)
Ok(mechanism) => mechanism, .map_err(ProtocolError::Parsers)?;
Err(e) => return Err(ProtocolError::Parsers(e).into()),
};
this.send( this.send(
stream, stream,
Auth { Auth {
@ -78,7 +71,7 @@ impl<S: AsyncWrite> ClientAuth<S> {
} }
} }
Err(AuthError::NoMechanism.into()) Err(AuthError::NoMechanism)?
} }
fn send<N: Into<Element>>(&mut self, stream: XMPPStream<S>, nonza: N) { fn send<N: Into<Element>>(&mut self, stream: XMPPStream<S>, nonza: N) {
@ -107,7 +100,7 @@ impl<S: AsyncRead + AsyncWrite> Future for ClientAuth<S> {
Ok(Async::NotReady) Ok(Async::NotReady)
}, },
Err(e) => Err(e) =>
Err(e.into()), Err(e)?,
}, },
ClientAuthState::WaitRecv(mut stream) => ClientAuthState::WaitRecv(mut stream) =>
match stream.poll() { match stream.poll() {
@ -122,7 +115,7 @@ impl<S: AsyncRead + AsyncWrite> Future for ClientAuth<S> {
self.state = ClientAuthState::Start(start); self.state = ClientAuthState::Start(start);
self.poll() self.poll()
} else if let Ok(failure) = Failure::try_from(stanza) { } else if let Ok(failure) = Failure::try_from(stanza) {
Err(AuthError::Fail(failure.defined_condition).into()) Err(AuthError::Fail(failure.defined_condition))?
} else { } else {
Ok(Async::NotReady) Ok(Async::NotReady)
} }
@ -136,7 +129,7 @@ impl<S: AsyncRead + AsyncWrite> Future for ClientAuth<S> {
Ok(Async::NotReady) Ok(Async::NotReady)
}, },
Err(e) => Err(e) =>
Err(ProtocolError::Parser(e).into()) Err(ProtocolError::Parser(e))?
}, },
ClientAuthState::Start(mut start) => ClientAuthState::Start(mut start) =>
match start.poll() { match start.poll() {
@ -147,7 +140,7 @@ impl<S: AsyncRead + AsyncWrite> Future for ClientAuth<S> {
Ok(Async::NotReady) Ok(Async::NotReady)
}, },
Err(e) => Err(e) =>
Err(e.into()) Err(e)
}, },
ClientAuthState::Invalid => ClientAuthState::Invalid =>
unreachable!(), unreachable!(),

6
src/client/bind.rs
View file

@ -61,7 +61,7 @@ impl<S: AsyncRead + AsyncWrite> Future for ClientBind<S> {
Ok(Async::NotReady) Ok(Async::NotReady)
}, },
Err(e) => Err(e) =>
Err(e.into()) Err(e)?
} }
}, },
ClientBind::WaitRecv(mut stream) => { ClientBind::WaitRecv(mut stream) => {
@ -80,7 +80,7 @@ impl<S: AsyncRead + AsyncWrite> Future for ClientBind<S> {
Ok(Async::Ready(stream)) Ok(Async::Ready(stream))
}, },
_ => _ =>
Err(ProtocolError::InvalidBindResponse.into()), Err(ProtocolError::InvalidBindResponse)?,
} }
} else { } else {
Ok(Async::NotReady) Ok(Async::NotReady)
@ -96,7 +96,7 @@ impl<S: AsyncRead + AsyncWrite> Future for ClientBind<S> {
Ok(Async::NotReady) Ok(Async::NotReady)
}, },
Err(e) => Err(e) =>
Err(e.into()), Err(e)?,
} }
}, },
ClientBind::Invalid => ClientBind::Invalid =>

6
src/client/mod.rs
View file

@ -147,7 +147,7 @@ impl Stream for Client {
Ok(Async::NotReady) => (), Ok(Async::NotReady) => (),
Ok(Async::Ready(())) => (), Ok(Async::Ready(())) => (),
Err(e) => Err(e) =>
return Err(e.into()), return Err(e)?,
}; };
// Poll stream // Poll stream
@ -167,7 +167,7 @@ impl Stream for Client {
Ok(Async::NotReady) Ok(Async::NotReady)
}, },
Err(e) => Err(e) =>
Err(e.into()), Err(e)?,
} }
}, },
} }
@ -190,7 +190,7 @@ impl Sink for Client {
Ok(AsyncSink::Ready) Ok(AsyncSink::Ready)
}, },
Err(e) => Err(e) =>
Err(e.into()), Err(e)?,
}, },
_ => _ =>
Ok(AsyncSink::NotReady(item)), Ok(AsyncSink::NotReady(item)),

6
src/component/auth.rs
View file

@ -31,7 +31,7 @@ impl<S: AsyncWrite> ComponentAuth<S> {
stream, stream,
Handshake::from_password_and_stream_id(&password, &sid) Handshake::from_password_and_stream_id(&password, &sid)
); );
return Ok(this); Ok(this)
} }
fn send(&mut self, stream: XMPPStream<S>, handshake: Handshake) { fn send(&mut self, stream: XMPPStream<S>, handshake: Handshake) {
@ -61,7 +61,7 @@ impl<S: AsyncRead + AsyncWrite> Future for ComponentAuth<S> {
Ok(Async::NotReady) Ok(Async::NotReady)
}, },
Err(e) => Err(e) =>
Err(e.into()), Err(e)?
}, },
ComponentAuthState::WaitRecv(mut stream) => ComponentAuthState::WaitRecv(mut stream) =>
match stream.poll() { match stream.poll() {
@ -85,7 +85,7 @@ impl<S: AsyncRead + AsyncWrite> Future for ComponentAuth<S> {
Ok(Async::NotReady) Ok(Async::NotReady)
}, },
Err(e) => Err(e) =>
Err(e.into()), Err(e)?
}, },
ComponentAuthState::Invalid => ComponentAuthState::Invalid =>
unreachable!(), unreachable!(),

6
src/component/mod.rs
View file

@ -100,7 +100,7 @@ impl Stream for Component {
Ok(Async::NotReady) => (), Ok(Async::NotReady) => (),
Ok(Async::Ready(())) => (), Ok(Async::Ready(())) => (),
Err(e) => Err(e) =>
return Err(e.into()), return Err(e)?,
}; };
// Poll stream // Poll stream
@ -123,7 +123,7 @@ impl Stream for Component {
Ok(Async::NotReady) Ok(Async::NotReady)
}, },
Err(e) => Err(e) =>
Err(e.into()), Err(e)?,
} }
}, },
} }
@ -146,7 +146,7 @@ impl Sink for Component {
Ok(AsyncSink::Ready) Ok(AsyncSink::Ready)
}, },
Err(e) => Err(e) =>
Err(e.into()), Err(e)?,
}, },
_ => _ =>
Ok(AsyncSink::NotReady(item)), Ok(AsyncSink::NotReady(item)),

8
src/happy_eyeballs.rs
View file

@ -50,13 +50,11 @@ impl Future for Connecter {
fn poll(&mut self) -> Poll<Self::Item, Self::Error> { fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
if self.resolver_opt.is_none() { if self.resolver_opt.is_none() {
//println!("Poll resolver future"); //println!("Poll resolver future");
match self.resolver_future.poll() { match self.resolver_future.poll()? {
Ok(Async::Ready(resolver)) => Async::Ready(resolver) =>
self.resolver_opt = Some(resolver), self.resolver_opt = Some(resolver),
Ok(Async::NotReady) => Async::NotReady =>
return Ok(Async::NotReady), return Ok(Async::NotReady),
Err(e) =>
return Err(e.into()),
} }
} }

76
src/stream_start.rs
View file

@ -1,6 +1,4 @@
use std::mem::replace; use std::mem::replace;
// use std::error::Error as StdError;
// use std::{fmt, io};
use futures::{Future, Async, Poll, Stream, sink, Sink}; use futures::{Future, Async, Poll, Stream, sink, Sink};
use tokio_io::{AsyncRead, AsyncWrite}; use tokio_io::{AsyncRead, AsyncWrite};
use tokio_codec::Framed; use tokio_codec::Framed;
@ -66,22 +64,18 @@ impl<S: AsyncRead + AsyncWrite> Future for StreamStart<S> {
StreamStartState::RecvStart(mut stream) => StreamStartState::RecvStart(mut stream) =>
match stream.poll() { match stream.poll() {
Ok(Async::Ready(Some(Packet::StreamStart(stream_attrs)))) => { Ok(Async::Ready(Some(Packet::StreamStart(stream_attrs)))) => {
let stream_ns = match stream_attrs.get("xmlns") { let stream_ns = stream_attrs.get("xmlns")
Some(ns) => ns.clone(), .ok_or(ProtocolError::NoStreamNamespace)?
None => .clone();
return Err(ProtocolError::NoStreamNamespace.into()),
};
if self.ns == "jabber:client" { if self.ns == "jabber:client" {
retry = true; retry = true;
// TODO: skip RecvFeatures for version < 1.0 // TODO: skip RecvFeatures for version < 1.0
(StreamStartState::RecvFeatures(stream, stream_ns), Ok(Async::NotReady)) (StreamStartState::RecvFeatures(stream, stream_ns), Ok(Async::NotReady))
} else { } else {
let id = match stream_attrs.get("id") { let id = stream_attrs.get("id")
Some(id) => id.clone(), .ok_or(ProtocolError::NoStreamId)?
None => .clone();
return Err(ProtocolError::NoStreamId.into()), // FIXME: huge hack, shouldn’t be an element!
};
// FIXME: huge hack, shouldn’t be an element!
let stream = XMPPStream::new(self.jid.clone(), stream, self.ns.clone(), Element::builder(id).build()); let stream = XMPPStream::new(self.jid.clone(), stream, self.ns.clone(), Element::builder(id).build());
(StreamStartState::Invalid, Ok(Async::Ready(stream))) (StreamStartState::Invalid, Ok(Async::Ready(stream)))
} }
@ -119,59 +113,3 @@ impl<S: AsyncRead + AsyncWrite> Future for StreamStart<S> {
} }
} }
} }
// #[derive(Debug)]
// pub enum StreamStartError {
// MissingStreamNs,
// MissingStreamId,
// Unexpected,
// Parser(ParserError),
// IO(io::Error),
// }
// impl From<io::Error> for StreamStartError {
// fn from(e: io::Error) -> Self {
// StreamStartError::IO(e)
// }
// }
// impl From<ParserError> for StreamStartError {
// fn from(e: ParserError) -> Self {
// match e {
// ParserError::IO(e) => StreamStartError::IO(e),
// _ => StreamStartError::Parser(e)
// }
// }
// }
// impl StdError for StreamStartError {
// fn description(&self) -> &str {
// match *self {
// StreamStartError::MissingStreamNs => "Missing stream namespace",
// StreamStartError::MissingStreamId => "Missing stream id",
// StreamStartError::Unexpected => "Unexpected",
// StreamStartError::Parser(ref pe) => pe.description(),
// StreamStartError::IO(ref ie) => ie.description(),
// }
// }
// fn cause(&self) -> Option<&StdError> {
// match *self {
// StreamStartError::Parser(ref pe) => pe.cause(),
// StreamStartError::IO(ref ie) => ie.cause(),
// _ => None,
// }
// }
// }
// impl fmt::Display for StreamStartError {
// fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
// match *self {
// StreamStartError::MissingStreamNs => write!(f, "Missing stream namespace"),
// StreamStartError::MissingStreamId => write!(f, "Missing stream id"),
// StreamStartError::Unexpected => write!(f, "Received unexpected data"),
// StreamStartError::Parser(ref pe) => write!(f, "{}", pe),
// StreamStartError::IO(ref ie) => write!(f, "{}", ie),
// }
// }
// }