use std::str;
use quick_xml::{
de::Deserializer,
events::{BytesDecl, BytesStart, Event},
name::QName,
Reader, Writer,
};
use serde::Deserialize;
use tokio::io::{BufReader, ReadHalf, WriteHalf};
use tokio::net::TcpStream;
use tokio_native_tls::native_tls::TlsConnector;
use crate::Result;
use crate::{error::JabberError, stanza::stream::StreamFeature};
use crate::{stanza::stream::StreamFeatures, Jabber};
pub struct JabberClient<'j> {
reader: Reader<BufReader<ReadHalf<TcpStream>>>,
writer: Writer<WriteHalf<TcpStream>>,
jabber: &'j mut Jabber<'j>,
}
impl<'j> JabberClient<'j> {
pub fn new(
reader: Reader<BufReader<ReadHalf<TcpStream>>>,
writer: Writer<WriteHalf<TcpStream>>,
jabber: &'j mut Jabber<'j>,
) -> Self {
Self {
reader,
writer,
jabber,
}
}
pub async fn start_stream(&mut self) -> Result<()> {
let declaration = BytesDecl::new("1.0", None, None);
let mut stream_element = BytesStart::new("stream:stream");
stream_element.push_attribute(("from".as_bytes(), self.jabber.jid.to_string().as_bytes()));
stream_element.push_attribute(("to".as_bytes(), self.jabber.server.as_bytes()));
stream_element.push_attribute(("version", "1.0"));
stream_element.push_attribute(("xml:lang", "en"));
stream_element.push_attribute(("xmlns", "jabber:client"));
stream_element.push_attribute(("xmlns:stream", "http://etherx.jabber.org/streams"));
self.writer
.write_event_async(Event::Decl(declaration))
.await;
self.writer
.write_event_async(Event::Start(stream_element))
.await
.unwrap();
let mut buf = Vec::new();
loop {
match self.reader.read_event_into_async(&mut buf).await.unwrap() {
Event::Start(e) => {
println!("{:?}", e);
break;
}
Event::Decl(e) => println!("decl: {:?}", e),
_ => return Err(JabberError::BadStream),
}
}
Ok(())
}
pub async fn get_features(&mut self) -> Result<Vec<StreamFeature>> {
let mut buf = Vec::new();
let mut txt = Vec::new();
let mut loop_end = false;
while !loop_end {
match self.reader.read_event_into_async(&mut buf).await.unwrap() {
Event::End(e) => {
if e.name() == QName(b"stream:features") {
loop_end = true;
}
}
_ => (),
}
txt.push(b'<');
txt = txt
.into_iter()
.chain(buf.to_owned())
.chain(vec![b'>'])
.collect();
buf.clear();
}
println!("{:?}", txt);
let decoded = str::from_utf8(&txt).unwrap();
println!("decoded: {:?}", decoded);
let mut deserializer = Deserializer::from_str(decoded);
let features = StreamFeatures::deserialize(&mut deserializer).unwrap();
println!("{:?}", features);
Ok(features.features)
}
pub async fn starttls(mut self) -> Result<super::encrypted::JabberClient<'j>> {
let mut starttls_element = BytesStart::new("starttls");
starttls_element.push_attribute(("xmlns", "urn:ietf:params:xml:ns:xmpp-tls"));
self.writer
.write_event_async(Event::Empty(starttls_element))
.await
.unwrap();
let mut buf = Vec::new();
match self.reader.read_event_into_async(&mut buf).await.unwrap() {
Event::Empty(e) => match e.name() {
QName(b"proceed") => {
let connector = TlsConnector::new().unwrap();
let stream = self
.reader
.into_inner()
.into_inner()
.unsplit(self.writer.into_inner());
if let Ok(tlsstream) = tokio_native_tls::TlsConnector::from(connector)
.connect(&self.jabber.server, stream)
.await
{
let (read, writer) = tokio::io::split(tlsstream);
let reader = Reader::from_reader(BufReader::new(read));
let mut client =
super::encrypted::JabberClient::new(reader, writer, self.jabber);
client.start_stream().await?;
return Ok(client);
}
}
QName(_) => return Err(JabberError::TlsNegotiation),
},
_ => return Err(JabberError::TlsNegotiation),
}
Err(JabberError::TlsNegotiation)
}
}
