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

Revert "Merge branch 'update-deps' into 'master'"

Browse source 
This reverts merge request !32
This commit is contained in:
Maxime Buquet 2017-12-31 13:56:17 +00:00
commit 8c4bb1b810
11 changed files with 194 additions and 213 deletions
Download patch file Download diff file Expand all files Collapse all files

128
src/transport.rs
View file

@ -1,13 +1,11 @@
//! Provides transports for the xml streams.
use std::io::BufReader;
use std::io::prelude::*;
use std::str;
use std::net::{TcpStream, Shutdown};
use quick_xml::reader::{Reader as EventReader};
use quick_xml::events::Event;
use xml::reader::{EventReader, XmlEvent as XmlReaderEvent};
use xml::writer::{EventWriter, XmlEvent as XmlWriterEvent, EmitterConfig};
use std::sync::{Arc, Mutex};
@ -26,11 +24,11 @@ use sasl::common::ChannelBinding;
/// A trait which transports are required to implement.
pub trait Transport {
/// Writes a `quick_xml::events::Event` to the stream.
fn write_event<'a, E: Into<Event<'a>>>(&mut self, event: E) -> Result<(), Error>;
/// Writes an `xml::writer::XmlEvent` to the stream.
fn write_event<'a, E: Into<XmlWriterEvent<'a>>>(&mut self, event: E) -> Result<(), Error>;
/// Reads a `quick_xml::events::Event` from the stream.
fn read_event(&mut self) -> Result<Event, Error>;
/// Reads an `xml::reader::XmlEvent` from the stream.
fn read_event(&mut self) -> Result<XmlReaderEvent, Error>;
/// Writes a `minidom::Element` to the stream.
fn write_element(&mut self, element: &minidom::Element) -> Result<(), Error>;
@ -50,21 +48,19 @@ pub trait Transport {
/// A plain text transport, completely unencrypted.
pub struct PlainTransport {
inner: Arc<Mutex<TcpStream>>, // TODO: this feels rather ugly
// TODO: especially feels ugly because this read would keep the lock held very long
// (potentially)
reader: EventReader<BufReader<LockedIO<TcpStream>>>,
writer: LockedIO<TcpStream>,
buf: Vec<u8>,
reader: EventReader<LockedIO<TcpStream>>, // TODO: especially feels ugly because
// this read would keep the lock
// held very long (potentially)
writer: EventWriter<LockedIO<TcpStream>>,
}
impl Transport for PlainTransport {
fn write_event<'a, E: Into<Event<'a>>>(&mut self, event: E) -> Result<(), Error> {
self.writer.write(&event.into())?;
Ok(())
fn write_event<'a, E: Into<XmlWriterEvent<'a>>>(&mut self, event: E) -> Result<(), Error> {
Ok(self.writer.write(event)?)
}
fn read_event(&mut self) -> Result<Event, Error> {
Ok(self.reader.read_event(&mut self.buf)?)
fn read_event(&mut self) -> Result<XmlReaderEvent, Error> {
Ok(self.reader.next()?)
}
fn write_element(&mut self, element: &minidom::Element) -> Result<(), Error> {
@ -78,8 +74,13 @@ impl Transport for PlainTransport {
fn reset_stream(&mut self) {
let locked_io = LockedIO::from(self.inner.clone());
self.reader = EventReader::from_reader(BufReader::new(locked_io.clone()));
self.writer = locked_io;
self.reader = EventReader::new(locked_io.clone());
self.writer = EventWriter::new_with_config(locked_io, EmitterConfig {
line_separator: "".into(),
perform_indent: false,
normalize_empty_elements: false,
.. Default::default()
});
}
fn channel_bind(&self) -> ChannelBinding {
@ -92,16 +93,21 @@ impl PlainTransport {
/// Connects to a server without any encryption.
pub fn connect(host: &str, port: u16) -> Result<PlainTransport, Error> {
let tcp_stream = TcpStream::connect((host, port))?;
let stream = Arc::new(Mutex::new(tcp_stream));
let parser = EventReader::new(tcp_stream);
let parser_stream = parser.into_inner();
let stream = Arc::new(Mutex::new(parser_stream));
let locked_io = LockedIO::from(stream.clone());
let reader = EventReader::from_reader(BufReader::new(locked_io.clone()));
let writer = locked_io;
let reader = EventReader::new(locked_io.clone());
let writer = EventWriter::new_with_config(locked_io, EmitterConfig {
line_separator: "".into(),
perform_indent: false,
normalize_empty_elements: false,
.. Default::default()
});
Ok(PlainTransport {
inner: stream,
reader: reader,
writer: writer,
buf: Vec::new(),
})
}
@ -117,21 +123,19 @@ impl PlainTransport {
/// A transport which uses STARTTLS.
pub struct SslTransport {
inner: Arc<Mutex<SslStream<TcpStream>>>, // TODO: this feels rather ugly
// TODO: especially feels ugly because this read would keep the lock held very long
// (potentially)
reader: EventReader<BufReader<LockedIO<SslStream<TcpStream>>>>,
writer: LockedIO<SslStream<TcpStream>>,
buf: Vec<u8>,
reader: EventReader<LockedIO<SslStream<TcpStream>>>, // TODO: especially feels ugly because
// this read would keep the lock
// held very long (potentially)
writer: EventWriter<LockedIO<SslStream<TcpStream>>>,
}
impl Transport for SslTransport {
fn write_event<'a, E: Into<Event<'a>>>(&mut self, event: E) -> Result<(), Error> {
self.writer.write(&event.into())?;
Ok(())
fn write_event<'a, E: Into<XmlWriterEvent<'a>>>(&mut self, event: E) -> Result<(), Error> {
Ok(self.writer.write(event)?)
}
fn read_event(&mut self) -> Result<Event, Error> {
Ok(self.reader.read_event(&mut self.buf)?)
fn read_event(&mut self) -> Result<XmlReaderEvent, Error> {
Ok(self.reader.next()?)
}
fn write_element(&mut self, element: &minidom::Element) -> Result<(), Error> {
@ -144,8 +148,13 @@ impl Transport for SslTransport {
fn reset_stream(&mut self) {
let locked_io = LockedIO::from(self.inner.clone());
self.reader = EventReader::from_reader(BufReader::new(locked_io.clone()));
self.writer = locked_io;
self.reader = EventReader::new(locked_io.clone());
self.writer = EventWriter::new_with_config(locked_io, EmitterConfig {
line_separator: "".into(),
perform_indent: false,
normalize_empty_elements: false,
.. Default::default()
});
}
fn channel_bind(&self) -> ChannelBinding {
@ -163,29 +172,23 @@ impl SslTransport {
, ns::CLIENT, ns::STREAM, host)?;
write!(stream, "<starttls xmlns='{}'/>"
, ns::TLS)?;
{
let mut parser = EventReader::from_reader(BufReader::new(&stream));
let mut buf = Vec::new();
let ns_buf = Vec::new();
loop { // TODO: possibly a timeout?
match parser.read_event(&mut buf)? {
Event::Start(ref e) => {
let (namespace, local_name) = parser.resolve_namespace(e.name(), &ns_buf);
let namespace = namespace.map(str::from_utf8);
let local_name = str::from_utf8(local_name)?;
if let Some(ns) = namespace {
if ns == Ok(ns::TLS) && local_name == "proceed" {
break;
} else if ns == Ok(ns::STREAM) && local_name == "error" {
return Err(Error::StreamError);
}
let mut parser = EventReader::new(stream);
loop { // TODO: possibly a timeout?
match parser.next()? {
XmlReaderEvent::StartElement { name, .. } => {
if let Some(ns) = name.namespace {
if ns == ns::TLS && name.local_name == "proceed" {
break;
}
},
_ => (),
}
else if ns == ns::STREAM && name.local_name == "error" {
return Err(Error::StreamError);
}
}
},
_ => {},
}
}
let stream = parser.into_inner();
#[cfg(feature = "insecure")]
let ssl_stream = {
let mut ctx = SslContextBuilder::new(SslMethod::tls())?;
@ -200,14 +203,17 @@ impl SslTransport {
};
let ssl_stream = Arc::new(Mutex::new(ssl_stream));
let locked_io = LockedIO::from(ssl_stream.clone());
let reader = EventReader::from_reader(BufReader::new(locked_io.clone()));
let writer = locked_io;
let reader = EventReader::new(locked_io.clone());
let writer = EventWriter::new_with_config(locked_io, EmitterConfig {
line_separator: "".into(),
perform_indent: false,
normalize_empty_elements: false,
.. Default::default()
});
Ok(SslTransport {
inner: ssl_stream,
reader: reader,
writer: writer,
buf: Vec::new(),
})
}