@@ -0,0 +1,168 @@
+use jid::Jid;
+use transport::{Transport, PlainTransport};
+use error::Error;
+use ns;
+use plugin::{Plugin, PluginProxyBinding};
+use event::AbstractEvent;
+use connection::{Connection, Component2S};
+use openssl::hash::{hash, MessageDigest};
+
+use minidom::Element;
+
+use xml::reader::XmlEvent as ReaderEvent;
+
+use std::sync::mpsc::{Receiver, channel};
+
+/// A builder for `Component`s.
+pub struct ComponentBuilder {
+ jid: Jid,
+ secret: String,
+ host: Option<String>,
+ port: u16,
+}
+
+impl ComponentBuilder {
+ /// Creates a new builder for an XMPP component that will connect to `jid` with default parameters.
+ pub fn new(jid: Jid) -> ComponentBuilder {
+ ComponentBuilder {
+ jid: jid,
+ secret: "".to_owned(),
+ host: None,
+ port: 5347,
+ }
+ }
+
+ /// Sets the host to connect to.
+ pub fn host(mut self, host: String) -> ComponentBuilder {
+ self.host = Some(host);
+ self
+ }
+
+ /// Sets the port to connect to.
+ pub fn port(mut self, port: u16) -> ComponentBuilder {
+ self.port = port;
+ self
+ }
+
+ /// Sets the password to use.
+ pub fn password<P: Into<String>>(mut self, password: P) -> ComponentBuilder {
+ self.secret = password.into();
+ self
+ }
+
+ /// Connects to the server and returns a `Component` when succesful.
+ pub fn connect(self) -> Result<Component, Error> {
+ let host = &self.host.unwrap_or(self.jid.domain.clone());
+ let mut transport = PlainTransport::connect(host, self.port)?;
+ Component2S::init(&mut transport, &self.jid.domain, "stream_opening")?;
+ let (sender_out, sender_in) = channel();
+ let (dispatcher_out, dispatcher_in) = channel();
+ let mut component = Component {
+ jid: self.jid,
+ transport: transport,
+ plugins: Vec::new(),
+ binding: PluginProxyBinding::new(sender_out, dispatcher_out),
+ sender_in: sender_in,
+ dispatcher_in: dispatcher_in,
+ };
+ component.connect(self.secret)?;
+ Ok(component)
+ }
+}
+
+/// An XMPP component.
+pub struct Component {
+ jid: Jid,
+ transport: PlainTransport,
+ plugins: Vec<Box<Plugin>>,
+ binding: PluginProxyBinding,
+ sender_in: Receiver<Element>,
+ dispatcher_in: Receiver<AbstractEvent>,
+}
+
+impl Component {
+ /// Returns a reference to the `Jid` associated with this `Component`.
+ pub fn jid(&self) -> &Jid {
+ &self.jid
+ }
+
+ /// Registers a plugin.
+ pub fn register_plugin<P: Plugin + 'static>(&mut self, mut plugin: P) {
+ plugin.bind(self.binding.clone());
+ self.plugins.push(Box::new(plugin));
+ }
+
+ /// Returns the plugin given by the type parameter, if it exists, else panics.
+ pub fn plugin<P: Plugin>(&self) -> &P {
+ for plugin in &self.plugins {
+ let any = plugin.as_any();
+ if let Some(ret) = any.downcast_ref::<P>() {
+ return ret;
+ }
+ }
+ panic!("plugin does not exist!");
+ }
+
+ /// Returns the next event and flush the send queue.
+ pub fn next_event(&mut self) -> Result<AbstractEvent, Error> {
+ self.flush_send_queue()?;
+ loop {
+ if let Ok(evt) = self.dispatcher_in.try_recv() {
+ return Ok(evt);
+ }
+ let elem = self.transport.read_element()?;
+ for plugin in self.plugins.iter_mut() {
+ plugin.handle(&elem);
+ // TODO: handle plugin return
+ }
+ self.flush_send_queue()?;
+ }
+ }
+
+ /// Flushes the send queue, sending all queued up stanzas.
+ pub fn flush_send_queue(&mut self) -> Result<(), Error> { // TODO: not sure how great of an
+ // idea it is to flush in this
+ // manner…
+ while let Ok(elem) = self.sender_in.try_recv() {
+ self.transport.write_element(&elem)?;
+ }
+ Ok(())
+ }
+
+ fn connect(&mut self, secret: String) -> Result<(), Error> {
+ // TODO: this is very ugly
+ let mut sid = String::new();
+ loop {
+ let e = self.transport.read_event()?;
+ match e {
+ ReaderEvent::StartElement { attributes, .. } => {
+ for attribute in attributes {
+ if attribute.name.namespace == None && attribute.name.local_name == "id" {
+ sid = attribute.value;
+ }
+ }
+ break;
+ },
+ _ => (),
+ }
+ }
+ let concatenated = format!("{}{}", sid, secret);
+ let hash = hash(MessageDigest::sha1(), concatenated.as_bytes())?;
+ let mut handshake = String::new();
+ for byte in hash {
+ // TODO: probably terrible perfs!
+ handshake = format!("{}{:x}", handshake, byte);
+ }
+ let mut elem = Element::builder("handshake")
+ .ns(ns::COMPONENT_ACCEPT)
+ .build();
+ elem.append_text_node(handshake);
+ self.transport.write_element(&elem)?;
+ loop {
+ let n = self.transport.read_element()?;
+ if n.is("handshake", ns::COMPONENT_ACCEPT) {
+ return Ok(());
+ }
+ }
+ }
+}