304 lines
11 KiB
Rust
304 lines
11 KiB
Rust
use xml;
|
|
use jid::Jid;
|
|
use transport::{Transport, SslTransport};
|
|
use error::Error;
|
|
use ns;
|
|
use plugin::{Plugin, PluginInit, PluginProxyBinding};
|
|
use connection::{Connection, C2S};
|
|
use sasl::client::Mechanism as SaslMechanism;
|
|
use sasl::client::mechanisms::{Plain, Scram};
|
|
use sasl::common::{Credentials as SaslCredentials, Identity, Secret, ChannelBinding};
|
|
use sasl::common::scram::{Sha1, Sha256};
|
|
use components::sasl_error::SaslError;
|
|
use util::FromElement;
|
|
use event::{Event, Dispatcher, Propagation, SendElement, ReceiveElement, Priority};
|
|
|
|
use base64;
|
|
|
|
use minidom::Element;
|
|
|
|
use xml::reader::XmlEvent as ReaderEvent;
|
|
|
|
use std::sync::{Mutex, Arc};
|
|
|
|
use std::collections::{HashSet, HashMap};
|
|
|
|
use std::any::TypeId;
|
|
|
|
/// Struct that should be moved somewhere else and cleaned up.
|
|
#[derive(Debug)]
|
|
pub struct StreamFeatures {
|
|
pub sasl_mechanisms: Option<HashSet<String>>,
|
|
}
|
|
|
|
/// A builder for `Client`s.
|
|
pub struct ClientBuilder {
|
|
jid: Jid,
|
|
credentials: SaslCredentials,
|
|
host: Option<String>,
|
|
port: u16,
|
|
}
|
|
|
|
impl ClientBuilder {
|
|
/// Creates a new builder for an XMPP client that will connect to `jid` with default parameters.
|
|
pub fn new(jid: Jid) -> ClientBuilder {
|
|
ClientBuilder {
|
|
jid: jid,
|
|
credentials: SaslCredentials::default(),
|
|
host: None,
|
|
port: 5222,
|
|
}
|
|
}
|
|
|
|
/// Sets the host to connect to.
|
|
pub fn host(mut self, host: String) -> ClientBuilder {
|
|
self.host = Some(host);
|
|
self
|
|
}
|
|
|
|
/// Sets the port to connect to.
|
|
pub fn port(mut self, port: u16) -> ClientBuilder {
|
|
self.port = port;
|
|
self
|
|
}
|
|
|
|
/// Sets the password to use.
|
|
pub fn password<P: Into<String>>(mut self, password: P) -> ClientBuilder {
|
|
self.credentials = SaslCredentials {
|
|
identity: Identity::Username(self.jid.node.clone().expect("JID has no node")),
|
|
secret: Secret::password_plain(password),
|
|
channel_binding: ChannelBinding::None,
|
|
};
|
|
self
|
|
}
|
|
|
|
/// Connects to the server and returns a `Client` when succesful.
|
|
pub fn connect(self) -> Result<Client, Error> {
|
|
let host = &self.host.unwrap_or(self.jid.domain.clone());
|
|
let mut transport = SslTransport::connect(host, self.port)?;
|
|
C2S::init(&mut transport, &self.jid.domain, "before_sasl")?;
|
|
let dispatcher = Arc::new(Dispatcher::new());
|
|
let mut credentials = self.credentials;
|
|
credentials.channel_binding = transport.channel_bind();
|
|
let transport = Arc::new(Mutex::new(transport));
|
|
let mut client = Client {
|
|
jid: self.jid,
|
|
transport: transport.clone(),
|
|
plugins: HashMap::new(),
|
|
binding: PluginProxyBinding::new(dispatcher.clone()),
|
|
dispatcher: dispatcher,
|
|
};
|
|
client.dispatcher.register(Priority::Default, move |evt: &SendElement| {
|
|
let mut t = transport.lock().unwrap();
|
|
t.write_element(&evt.0).unwrap();
|
|
Propagation::Continue
|
|
});
|
|
client.connect(credentials)?;
|
|
client.bind()?;
|
|
Ok(client)
|
|
}
|
|
}
|
|
|
|
/// An XMPP client.
|
|
pub struct Client {
|
|
jid: Jid,
|
|
transport: Arc<Mutex<SslTransport>>,
|
|
plugins: HashMap<TypeId, Arc<Box<Plugin>>>,
|
|
binding: PluginProxyBinding,
|
|
dispatcher: Arc<Dispatcher>,
|
|
}
|
|
|
|
impl Client {
|
|
/// Returns a reference to the `Jid` associated with this `Client`.
|
|
pub fn jid(&self) -> &Jid {
|
|
&self.jid
|
|
}
|
|
|
|
/// Registers a plugin.
|
|
pub fn register_plugin<P: Plugin + PluginInit + 'static>(&mut self, mut plugin: P) {
|
|
let binding = self.binding.clone();
|
|
plugin.bind(binding);
|
|
let p = Arc::new(Box::new(plugin) as Box<Plugin>);
|
|
P::init(&self.dispatcher, p.clone());
|
|
if self.plugins.insert(TypeId::of::<P>(), p).is_some() {
|
|
panic!("registering a plugin that's already registered");
|
|
}
|
|
}
|
|
|
|
pub fn register_handler<E, F>(&mut self, pri: Priority, func: F)
|
|
where
|
|
E: Event,
|
|
F: Fn(&E) -> Propagation + 'static {
|
|
self.dispatcher.register(pri, func);
|
|
}
|
|
|
|
/// Returns the plugin given by the type parameter, if it exists, else panics.
|
|
pub fn plugin<P: Plugin>(&self) -> &P {
|
|
self.plugins.get(&TypeId::of::<P>())
|
|
.expect("the requested plugin was not registered")
|
|
.as_any()
|
|
.downcast_ref::<P>()
|
|
.expect("plugin downcast failure (should not happen!!)")
|
|
}
|
|
|
|
/// Returns the next event and flush the send queue.
|
|
pub fn main(&mut self) -> Result<(), Error> {
|
|
self.dispatcher.flush_all();
|
|
loop {
|
|
let elem = self.read_element()?;
|
|
self.dispatcher.dispatch(ReceiveElement(elem));
|
|
self.dispatcher.flush_all();
|
|
}
|
|
}
|
|
|
|
fn reset_stream(&self) {
|
|
self.transport.lock().unwrap().reset_stream()
|
|
}
|
|
|
|
fn read_element(&self) -> Result<Element, Error> {
|
|
self.transport.lock().unwrap().read_element()
|
|
}
|
|
|
|
fn write_element(&self, elem: &Element) -> Result<(), Error> {
|
|
self.transport.lock().unwrap().write_element(elem)
|
|
}
|
|
|
|
fn read_event(&self) -> Result<xml::reader::XmlEvent, Error> {
|
|
self.transport.lock().unwrap().read_event()
|
|
}
|
|
|
|
fn connect(&mut self, mut credentials: SaslCredentials) -> Result<(), Error> {
|
|
let features = self.wait_for_features()?;
|
|
let ms = &features.sasl_mechanisms.ok_or(Error::SaslError(Some("no SASL mechanisms".to_owned())))?;
|
|
fn wrap_err(err: String) -> Error { Error::SaslError(Some(err)) }
|
|
// TODO: better way for selecting these, enabling anonymous auth
|
|
let mut mechanism: Box<SaslMechanism> = if ms.contains("SCRAM-SHA-256-PLUS") && credentials.channel_binding != ChannelBinding::None {
|
|
Box::new(Scram::<Sha256>::from_credentials(credentials).map_err(wrap_err)?)
|
|
}
|
|
else if ms.contains("SCRAM-SHA-1-PLUS") && credentials.channel_binding != ChannelBinding::None {
|
|
Box::new(Scram::<Sha1>::from_credentials(credentials).map_err(wrap_err)?)
|
|
}
|
|
else if ms.contains("SCRAM-SHA-256") {
|
|
if credentials.channel_binding != ChannelBinding::None {
|
|
credentials.channel_binding = ChannelBinding::Unsupported;
|
|
}
|
|
Box::new(Scram::<Sha256>::from_credentials(credentials).map_err(wrap_err)?)
|
|
}
|
|
else if ms.contains("SCRAM-SHA-1") {
|
|
if credentials.channel_binding != ChannelBinding::None {
|
|
credentials.channel_binding = ChannelBinding::Unsupported;
|
|
}
|
|
Box::new(Scram::<Sha1>::from_credentials(credentials).map_err(wrap_err)?)
|
|
}
|
|
else if ms.contains("PLAIN") {
|
|
Box::new(Plain::from_credentials(credentials).map_err(wrap_err)?)
|
|
}
|
|
else {
|
|
return Err(Error::SaslError(Some("can't find a SASL mechanism to use".to_owned())));
|
|
};
|
|
let auth = mechanism.initial().map_err(|x| Error::SaslError(Some(x)))?;
|
|
let mut elem = Element::builder("auth")
|
|
.ns(ns::SASL)
|
|
.attr("mechanism", mechanism.name())
|
|
.build();
|
|
if !auth.is_empty() {
|
|
elem.append_text_node(base64::encode(&auth));
|
|
}
|
|
self.write_element(&elem)?;
|
|
loop {
|
|
let n = self.read_element()?;
|
|
if n.is("challenge", ns::SASL) {
|
|
let text = n.text();
|
|
let challenge = if text == "" {
|
|
Vec::new()
|
|
}
|
|
else {
|
|
base64::decode(&text)?
|
|
};
|
|
let response = mechanism.response(&challenge).map_err(|x| Error::SaslError(Some(x)))?;
|
|
let mut elem = Element::builder("response")
|
|
.ns(ns::SASL)
|
|
.build();
|
|
if !response.is_empty() {
|
|
elem.append_text_node(base64::encode(&response));
|
|
}
|
|
self.write_element(&elem)?;
|
|
}
|
|
else if n.is("success", ns::SASL) {
|
|
let text = n.text();
|
|
let data = if text == "" {
|
|
Vec::new()
|
|
}
|
|
else {
|
|
base64::decode(&text)?
|
|
};
|
|
mechanism.success(&data).map_err(|x| Error::SaslError(Some(x)))?;
|
|
self.reset_stream();
|
|
{
|
|
let mut g = self.transport.lock().unwrap();
|
|
C2S::init(&mut *g, &self.jid.domain, "after_sasl")?;
|
|
}
|
|
self.wait_for_features()?;
|
|
return Ok(());
|
|
}
|
|
else if n.is("failure", ns::SASL) {
|
|
let inner = SaslError::from_element(&n).map_err(|_| Error::SaslError(None))?;
|
|
return Err(Error::XmppSaslError(inner));
|
|
}
|
|
}
|
|
}
|
|
|
|
fn bind(&mut self) -> Result<(), Error> {
|
|
let mut elem = Element::builder("iq")
|
|
.attr("id", "bind")
|
|
.attr("type", "set")
|
|
.build();
|
|
let mut bind = Element::builder("bind")
|
|
.ns(ns::BIND)
|
|
.build();
|
|
if let Some(ref resource) = self.jid.resource {
|
|
let res = Element::builder("resource")
|
|
.ns(ns::BIND)
|
|
.append(resource.to_owned())
|
|
.build();
|
|
bind.append_child(res);
|
|
}
|
|
elem.append_child(bind);
|
|
self.write_element(&elem)?;
|
|
loop {
|
|
let n = self.read_element()?;
|
|
if n.is("iq", ns::CLIENT) && n.has_child("bind", ns::BIND) {
|
|
return Ok(());
|
|
}
|
|
}
|
|
}
|
|
|
|
fn wait_for_features(&mut self) -> Result<StreamFeatures, Error> {
|
|
// TODO: this is very ugly
|
|
loop {
|
|
let e = self.read_event()?;
|
|
match e {
|
|
ReaderEvent::StartElement { .. } => {
|
|
break;
|
|
},
|
|
_ => (),
|
|
}
|
|
}
|
|
loop {
|
|
let n = self.read_element()?;
|
|
if n.is("features", ns::STREAM) {
|
|
let mut features = StreamFeatures {
|
|
sasl_mechanisms: None,
|
|
};
|
|
if let Some(ms) = n.get_child("mechanisms", ns::SASL) {
|
|
let mut res = HashSet::new();
|
|
for cld in ms.children() {
|
|
res.insert(cld.text());
|
|
}
|
|
features.sasl_mechanisms = Some(res);
|
|
}
|
|
return Ok(features);
|
|
}
|
|
}
|
|
}
|
|
}
|