luz/src/jabber.rs

206 lines
8.8 KiB
Rust
Raw Normal View History

2023-07-04 21:27:15 +01:00
use std::sync::Arc;
2023-06-19 19:23:54 +01:00
2023-10-21 01:28:54 +01:00
use quick_xml::{events::Event, se::Serializer, NsReader, Writer};
2023-07-04 21:27:15 +01:00
use rsasl::prelude::SASLConfig;
2023-10-21 01:28:54 +01:00
use serde::Serialize;
use tokio::io::{AsyncRead, AsyncWrite, AsyncWriteExt, BufReader, ReadHalf, WriteHalf};
2023-06-19 19:23:54 +01:00
2023-10-21 01:28:54 +01:00
use crate::connection::{Tls, Unencrypted};
use crate::error::JabberError;
use crate::stanza::stream::Stream;
use crate::stanza::DECLARATION;
use crate::Result;
use crate::JID;
2023-06-19 19:23:54 +01:00
2023-10-21 01:28:54 +01:00
pub struct Jabber<S>
where
S: AsyncRead + AsyncWrite + Unpin,
{
reader: NsReader<BufReader<ReadHalf<S>>>,
writer: Writer<WriteHalf<S>>,
jid: Option<JID>,
auth: Option<Arc<SASLConfig>>,
server: String,
2023-06-19 19:23:54 +01:00
}
2023-10-21 01:28:54 +01:00
impl<S> Jabber<S>
where
S: AsyncRead + AsyncWrite + Unpin,
{
pub fn new(
reader: ReadHalf<S>,
writer: WriteHalf<S>,
jid: Option<JID>,
auth: Option<Arc<SASLConfig>>,
server: String,
) -> Self {
let reader = NsReader::from_reader(BufReader::new(reader));
let writer = Writer::new(writer);
Self {
reader,
writer,
2023-06-19 19:23:54 +01:00
jid,
2023-07-04 21:27:15 +01:00
auth,
2023-06-19 19:23:54 +01:00
server,
2023-10-21 01:28:54 +01:00
}
2023-06-19 19:23:54 +01:00
}
2023-10-21 01:28:54 +01:00
}
2023-06-19 19:23:54 +01:00
2023-10-21 01:28:54 +01:00
impl<S> Jabber<S>
where
S: AsyncRead + AsyncWrite + Unpin,
Writer<tokio::io::WriteHalf<S>>: AsyncWriteExt,
Writer<tokio::io::WriteHalf<S>>: AsyncWrite,
{
pub async fn start_stream(&mut self) -> Result<()> {
// client to server
2023-06-19 19:23:54 +01:00
2023-10-21 01:28:54 +01:00
// declaration
self.writer.write_event_async(DECLARATION.clone()).await?;
2023-06-19 19:23:54 +01:00
2023-10-21 01:28:54 +01:00
// opening stream element
let server = &self.server.to_owned().try_into()?;
let stream_element = Stream::new_client(None, server, None, "en");
// TODO: nicer function to serialize to xml writer
let mut buffer = String::new();
let ser = Serializer::new(&mut buffer);
stream_element.serialize(ser).unwrap();
self.writer.write_all(buffer.as_bytes());
2023-06-19 19:23:54 +01:00
2023-10-21 01:28:54 +01:00
// server to client
2023-06-19 19:23:54 +01:00
2023-10-21 01:28:54 +01:00
// may or may not send a declaration
let mut buf = Vec::new();
let mut first_event = self.reader.read_resolved_event_into_async(&mut buf).await?;
match first_event {
(quick_xml::name::ResolveResult::Unbound, Event::Decl(e)) => {
if let Ok(version) = e.version() {
if version.as_ref() == b"1.0" {
first_event = self.reader.read_resolved_event_into_async(&mut buf).await?
} else {
// todo: error
todo!()
}
} else {
first_event = self.reader.read_resolved_event_into_async(&mut buf).await?
2023-06-19 19:23:54 +01:00
}
}
2023-10-21 01:28:54 +01:00
_ => (),
2023-06-19 19:23:54 +01:00
}
2023-10-21 01:28:54 +01:00
// receive stream element and validate
let stream_response: Stream;
match first_event {
(quick_xml::name::ResolveResult::Bound(ns), Event::Start(e)) => {
if ns.0 == crate::stanza::stream::XMLNS.as_bytes() {
// stream_response = Stream::new(
// e.try_get_attribute("from")?.try_map(|attribute| {
// str::from_utf8(attribute.value.as_ref())?
// .try_into()?
// .as_ref()
// })?,
// e.try_get_attribute("to")?.try_map(|attribute| {
// str::from_utf8(attribute.value.as_ref())?
// .try_into()?
// .as_ref()
// })?,
// e.try_get_attribute("id")?.try_map(|attribute| {
// str::from_utf8(attribute.value.as_ref())?
// .try_into()?
// .as_ref()
// })?,
// e.try_get_attribute("version")?.try_map(|attribute| {
// str::from_utf8(attribute.value.as_ref())?
// .try_into()?
// .as_ref()
// })?,
// e.try_get_attribute("lang")?.try_map(|attribute| {
// str::from_utf8(attribute.value.as_ref())?
// .try_into()?
// .as_ref()
// })?,
// );
return Ok(());
} else {
return Err(JabberError::BadStream);
2023-06-19 19:23:54 +01:00
}
}
2023-10-21 01:28:54 +01:00
// TODO: errors for incorrect namespace
(quick_xml::name::ResolveResult::Unbound, Event::Decl(_)) => todo!(),
(quick_xml::name::ResolveResult::Unknown(_), Event::Start(_)) => todo!(),
(quick_xml::name::ResolveResult::Unknown(_), Event::End(_)) => todo!(),
(quick_xml::name::ResolveResult::Unknown(_), Event::Empty(_)) => todo!(),
(quick_xml::name::ResolveResult::Unknown(_), Event::Text(_)) => todo!(),
(quick_xml::name::ResolveResult::Unknown(_), Event::CData(_)) => todo!(),
(quick_xml::name::ResolveResult::Unknown(_), Event::Comment(_)) => todo!(),
(quick_xml::name::ResolveResult::Unknown(_), Event::Decl(_)) => todo!(),
(quick_xml::name::ResolveResult::Unknown(_), Event::PI(_)) => todo!(),
(quick_xml::name::ResolveResult::Unknown(_), Event::DocType(_)) => todo!(),
(quick_xml::name::ResolveResult::Unknown(_), Event::Eof) => todo!(),
(quick_xml::name::ResolveResult::Unbound, Event::Start(_)) => todo!(),
(quick_xml::name::ResolveResult::Unbound, Event::End(_)) => todo!(),
(quick_xml::name::ResolveResult::Unbound, Event::Empty(_)) => todo!(),
(quick_xml::name::ResolveResult::Unbound, Event::Text(_)) => todo!(),
(quick_xml::name::ResolveResult::Unbound, Event::CData(_)) => todo!(),
(quick_xml::name::ResolveResult::Unbound, Event::Comment(_)) => todo!(),
(quick_xml::name::ResolveResult::Unbound, Event::PI(_)) => todo!(),
(quick_xml::name::ResolveResult::Unbound, Event::DocType(_)) => todo!(),
(quick_xml::name::ResolveResult::Unbound, Event::Eof) => todo!(),
(quick_xml::name::ResolveResult::Bound(_), Event::End(_)) => todo!(),
(quick_xml::name::ResolveResult::Bound(_), Event::Empty(_)) => todo!(),
(quick_xml::name::ResolveResult::Bound(_), Event::Text(_)) => todo!(),
(quick_xml::name::ResolveResult::Bound(_), Event::CData(_)) => todo!(),
(quick_xml::name::ResolveResult::Bound(_), Event::Comment(_)) => todo!(),
(quick_xml::name::ResolveResult::Bound(_), Event::Decl(_)) => todo!(),
(quick_xml::name::ResolveResult::Bound(_), Event::PI(_)) => todo!(),
(quick_xml::name::ResolveResult::Bound(_), Event::DocType(_)) => todo!(),
(quick_xml::name::ResolveResult::Bound(_), Event::Eof) => todo!(),
2023-06-19 19:23:54 +01:00
}
}
}
2023-10-21 01:28:54 +01:00
// pub async fn get_features(&mut self) -> Result<Vec<StreamFeature>> {
// Element::read(&mut self.reader).await?.try_into()
// }
impl Jabber<Unencrypted> {
pub async fn starttls(mut self) -> Result<Jabber<Tls>> {
todo!()
}
// 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, write) = tokio::io::split(tlsstream);
// let reader = Reader::from_reader(BufReader::new(read));
// let writer = Writer::new(write);
// 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)
// }
}