cel
/
luz
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

WIP: refactor to parse incoming stream as state machine

This commit is contained in:
cel 🌸 2023-10-20 04:51:56 +01:00
parent 2536fa4937
commit ba94ee66fa
15 changed files with 238 additions and 1293 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Cargo.toml
View File

@ -10,9 +10,12 @@ edition = "2021"
async-recursion = "1.0.4"
async-trait = "0.1.68"
nanoid = "0.4.0"
quick-xml = { git = "https://github.com/tafia/quick-xml.git", features = ["async-tokio"] }
quick-xml = { git = "https://github.com/tafia/quick-xml.git", features = ["async-tokio", "serialize"] }
# TODO: remove unneeded features
rsasl = { version = "2", default_features = true, features = ["provider_base64", "plain", "config_builder"] }
serde = "1.0.180"
tokio = { version = "1.28", features = ["full"] }
tokio-native-tls = "0.3.1"
tracing = "0.1.40"
trust-dns-resolver = "0.22.0"
try_map = "0.3.1"

16
src/client/encrypted.rs
View File

@ -2,36 +2,26 @@ use std::{collections::BTreeMap, str};
use quick_xml::{
events::{BytesDecl, Event},
Reader, Writer,
NsReader, Writer,
};
use rsasl::prelude::{Mechname, SASLClient};
use tokio::io::{BufReader, ReadHalf, WriteHalf};
use tokio::net::TcpStream;
use tokio_native_tls::TlsStream;
use crate::stanza::{
bind::Bind,
iq::IQ,
sasl::{Challenge, Success},
Element,
};
use crate::stanza::{
sasl::{Auth, Response},
stream::{Stream, StreamFeature},
};
use crate::Jabber;
use crate::JabberError;
use crate::Result;
pub struct JabberClient<'j> {
pub reader: Reader<BufReader<ReadHalf<TlsStream<TcpStream>>>>,
pub reader: NsReader<BufReader<ReadHalf<TlsStream<TcpStream>>>>,
pub writer: Writer<WriteHalf<TlsStream<TcpStream>>>,
jabber: &'j mut Jabber<'j>,
}
impl<'j> JabberClient<'j> {
pub fn new(
reader: Reader<BufReader<ReadHalf<TlsStream<TcpStream>>>>,
reader: NsReader<BufReader<ReadHalf<TlsStream<TcpStream>>>>,
writer: Writer<WriteHalf<TlsStream<TcpStream>>>,
jabber: &'j mut Jabber<'j>,
) -> Self {

10
src/client/mod.rs
View File

@ -1,22 +1,24 @@
pub mod encrypted;
// pub mod encrypted;
pub mod unencrypted;
// use async_trait::async_trait;
use crate::stanza::stream::StreamFeature;
// use crate::stanza::stream::StreamFeature;
use crate::JabberError;
use crate::Result;
pub enum JabberClientType<'j> {
Encrypted(encrypted::JabberClient<'j>),
// Encrypted(encrypted::JabberClient<'j>),
Unencrypted(unencrypted::JabberClient<'j>),
}
impl<'j> JabberClientType<'j> {
/// ensures an encrypted jabber client
pub async fn ensure_tls(self) -> Result<encrypted::JabberClient<'j>> {
match self {
Self::Encrypted(c) => Ok(c),
Self::Unencrypted(mut c) => {
c.start_stream().await?;
let features = c.get_features().await?;
if features.contains(&StreamFeature::StartTls) {
Ok(c.starttls().await?)
@ -28,7 +30,7 @@ impl<'j> JabberClientType<'j> {
}
}
// TODO: jabber client trait over both client types
// TODO: jabber client trait over both client types using macro
// #[async_trait]
// pub trait JabberTrait {
// async fn start_stream(&mut self) -> Result<()>;

199
src/client/unencrypted.rs
View File

@ -1,27 +1,30 @@
use std::str;
use quick_xml::{
events::{BytesDecl, BytesStart, Event},
events::{BytesStart, Event},
name::QName,
Reader, Writer,
se, NsReader, Writer,
};
use tokio::io::{BufReader, ReadHalf, WriteHalf};
use tokio::net::TcpStream;
use tokio_native_tls::native_tls::TlsConnector;
use try_map::FallibleMapExt;
use crate::stanza::stream::StreamFeature;
use crate::stanza::Element;
use crate::error::JabberError;
use crate::stanza::stream::Stream;
use crate::stanza::DECLARATION;
use crate::Jabber;
use crate::Result;
use crate::{error::JabberError, stanza::stream::Stream};
pub struct JabberClient<'j> {
reader: Reader<BufReader<ReadHalf<TcpStream>>>,
reader: NsReader<BufReader<ReadHalf<TcpStream>>>,
writer: Writer<WriteHalf<TcpStream>>,
jabber: &'j mut Jabber<'j>,
}
impl<'j> JabberClient<'j> {
pub fn new(
reader: Reader<BufReader<ReadHalf<TcpStream>>>,
reader: NsReader<BufReader<ReadHalf<TcpStream>>>,
writer: Writer<WriteHalf<TcpStream>>,
jabber: &'j mut Jabber<'j>,
) -> Self {
@ -34,60 +37,144 @@ impl<'j> JabberClient<'j> {
pub async fn start_stream(&mut self) -> Result<()> {
// client to server
let declaration = BytesDecl::new("1.0", None, None);
// declaration
self.writer.write_event_async(DECLARATION).await?;
// opening stream element
let server = &self.jabber.server.to_owned().try_into()?;
let stream_element =
Stream::new_client(&self.jabber.jid, server, None, Some("en".to_string()));
self.writer
.write_event_async(Event::Decl(declaration))
.await?;
let stream_element: Element<'_> = stream_element.into();
stream_element.write_start(&mut self.writer).await?;
let stream_element = Stream::new_client(None, server, None, "en");
se::to_writer_with_root(&mut self.writer, "stream:stream", &stream_element);
// server to client
let mut buf = Vec::new();
self.reader.read_event_into_async(&mut buf).await?;
let _stream_response = Element::read_start(&mut self.reader).await?;
Ok(())
}
pub async fn get_features(&mut self) -> Result<Vec<StreamFeature>> {
Element::read(&mut self.reader).await?.try_into()
}
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, 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);
// may or may not send a declaration
let 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?
}
QName(_) => return Err(JabberError::TlsNegotiation),
},
_ => return Err(JabberError::TlsNegotiation),
}
_ => (),
}
// 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);
}
}
// 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!(),
}
Err(JabberError::TlsNegotiation)
}
// pub async fn get_features(&mut self) -> Result<Vec<StreamFeature>> {
// Element::read(&mut self.reader).await?.try_into()
// }
// 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, 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)
// }
}

18
src/jabber.rs
View File

@ -3,7 +3,7 @@ use std::net::{IpAddr, SocketAddr};
use std::str::FromStr;
use std::sync::Arc;
use quick_xml::{Reader, Writer};
use quick_xml::{NsReader, Writer};
use rsasl::prelude::SASLConfig;
use tokio::io::BufReader;
use tokio::net::TcpStream;
@ -22,7 +22,7 @@ pub struct Jabber<'j> {
}
impl<'j> Jabber<'j> {
pub fn new(jid: JID, password: String) -> Result<Self> {
pub fn user(jid: JID, password: String) -> Result<Self> {
let server = jid.domainpart.clone();
let auth = SASLConfig::with_credentials(None, jid.localpart.clone().unwrap(), password)?;
println!("auth: {:?}", auth);
@ -36,7 +36,7 @@ impl<'j> Jabber<'j> {
pub async fn login(&'j mut self) -> Result<JabberClient<'j>> {
let mut client = self.connect().await?.ensure_tls().await?;
println!("negotiation");
client.start_stream().await?;
client.negotiate().await?;
Ok(client)
}
@ -106,6 +106,7 @@ impl<'j> Jabber<'j> {
socket_addrs
}
/// establishes a connection to the server
pub async fn connect(&'j mut self) -> Result<JabberClientType> {
for (socket_addr, is_tls) in self.get_sockets().await {
println!("trying {}", socket_addr);
@ -118,21 +119,18 @@ impl<'j> Jabber<'j> {
.await
{
let (read, write) = tokio::io::split(stream);
let reader = Reader::from_reader(BufReader::new(read));
let reader = NsReader::from_reader(BufReader::new(read));
let writer = Writer::new(write);
let mut client = client::encrypted::JabberClient::new(reader, writer, self);
client.start_stream().await?;
let client = client::encrypted::JabberClient::new(reader, writer, self);
return Ok(JabberClientType::Encrypted(client));
}
}
false => {
if let Ok(stream) = TcpStream::connect(socket_addr).await {
let (read, write) = tokio::io::split(stream);
let reader = Reader::from_reader(BufReader::new(read));
let reader = NsReader::from_reader(BufReader::new(read));
let writer = Writer::new(write);
let mut client =
client::unencrypted::JabberClient::new(reader, writer, self);
client.start_stream().await?;
let client = client::unencrypted::JabberClient::new(reader, writer, self);
return Ok(JabberClientType::Unencrypted(client));
}
}

19
src/jid/mod.rs → src/jid.rs
View File

@ -1,5 +1,7 @@
use std::str::FromStr;
use serde::Serialize;
#[derive(PartialEq, Debug, Clone)]
pub struct JID {
// TODO: validate localpart (length, char]
@ -8,6 +10,15 @@ pub struct JID {
pub resourcepart: Option<String>,
}
impl Serialize for JID {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_str(&self.to_string())
}
}
pub enum JIDError {
NoResourcePart,
ParseError(ParseError),
@ -97,6 +108,14 @@ impl TryFrom<String> for JID {
}
}
impl TryFrom<&str> for JID {
type Error = ParseError;
fn try_from(value: &str) -> Result<Self, Self::Error> {
value.parse()
}
}
impl std::fmt::Display for JID {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(

25
src/lib.rs
View File

@ -8,7 +8,7 @@ pub mod jabber;
pub mod jid;
pub mod stanza;
pub use client::encrypted::JabberClient;
// pub use client::encrypted::JabberClient;
pub use error::JabberError;
pub use jabber::Jabber;
pub use jid::JID;
@ -22,30 +22,9 @@ mod tests {
use crate::Jabber;
use crate::JID;
// #[tokio::test]
// async fn get_sockets() {
// let jabber = Jabber::new(JID::from_str("cel@blos.sm").unwrap(), "password".to_owned());
// println!("{:?}", jabber.get_sockets().await)
// }
// #[tokio::test]
// async fn connect() {
// Jabber::new(JID::from_str("cel@blos.sm").unwrap(), "password".to_owned())
// .unwrap()
// .connect()
// .await
// .unwrap()
// .ensure_tls()
// .await
// .unwrap()
// .start_stream()
// .await
// .unwrap();
// }
#[tokio::test]
async fn login() {
Jabber::new(
Jabber::user(
JID::from_str("test@blos.sm/clown").unwrap(),
"slayed".to_owned(),
)

47
src/stanza/bind.rs
View File

@ -1,48 +1 @@
use super::{Element, ElementParseError};
use crate::{JabberError, JID};
const XMLNS: &str = "urn:ietf:params:xml:ns:xmpp-bind";
pub struct Bind {
pub resource: Option<String>,
pub jid: Option<JID>,
}
impl From<Bind> for Element {
fn from(bind: Bind) -> Self {
let bind_element = Element::new("bind", None, XMLNS);
bind_element.push_namespace_declaration((None, XMLNS));
if let Some(resource) = bind.resource {
let resource_element = Element::new("resource", None, XMLNS);
resource_element.push_child(resource);
bind_element.push_child(resource_element)
}
if let Some(jid) = bind.jid {
let jid_element = Element::new("jid", None, XMLNS);
jid_element.push_child(jid);
bind_element.push_child(jid_element)
}
bind_element
}
}
impl TryFrom<Element> for Bind {
type Error = JabberError;
fn try_from(element: Element) -> Result<Self, Self::Error> {
if element.namespace() == XMLNS && element.localname() == "bind" {
let (resource, jid);
let child: &Element = element.child()?;
if child.namespace() == XMLNS {
match child.localname() {
"resource" => Bind::new(Some(
child
.text_content()?
.first()
.ok_or(ElementParseError::NoContent)?,
)),
}
}
}
}
}

169
src/stanza/iq.rs
View File

@ -1,170 +1 @@
use nanoid::nanoid;
use quick_xml::{
events::{BytesStart, Event},
name::QName,
Reader, Writer,
};
use crate::{JabberClient, JabberError, JID};
use crate::Result;
#[derive(Debug)]
pub struct IQ {
to: Option<JID>,
from: Option<JID>,
id: String,
r#type: IQType,
lang: Option<String>,
child: Element<'static>,
}
#[derive(Debug)]
enum IQType {
Get,
Set,
Result,
Error,
}
impl IQ {
pub async fn set<'j, R: IntoElement<'static>>(
client: &mut JabberClient<'j>,
to: Option<JID>,
from: Option<JID>,
element: R,
) -> Result<Element<'static>> {
let id = nanoid!();
let iq = IQ {
to,
from,
id: id.clone(),
r#type: IQType::Set,
lang: None,
child: Element::from(element),
};
println!("{:?}", iq);
let iq = Element::from(iq);
println!("{:?}", iq);
iq.write(&mut client.writer).await?;
let result = Element::read(&mut client.reader).await?;
let iq = IQ::try_from(result)?;
if iq.id == id {
return Ok(iq.child);
}
Err(JabberError::IDMismatch)
}
}
impl<'e> IntoElement<'e> for IQ {
fn event(&self) -> quick_xml::events::Event<'e> {
let mut start = BytesStart::new("iq");
if let Some(to) = &self.to {
start.push_attribute(("to", to.to_string().as_str()));
}
if let Some(from) = &self.from {
start.push_attribute(("from", from.to_string().as_str()));
}
start.push_attribute(("id", self.id.as_str()));
match self.r#type {
IQType::Get => start.push_attribute(("type", "get")),
IQType::Set => start.push_attribute(("type", "set")),
IQType::Result => start.push_attribute(("type", "result")),
IQType::Error => start.push_attribute(("type", "error")),
}
if let Some(lang) = &self.lang {
start.push_attribute(("from", lang.to_string().as_str()));
}
quick_xml::events::Event::Start(start)
}
fn children(&self) -> Option<Vec<Element<'e>>> {
Some(vec![self.child.clone()])
}
}
impl TryFrom<Element<'static>> for IQ {
type Error = JabberError;
fn try_from(element: Element<'static>) -> std::result::Result<Self, Self::Error> {
if let Event::Start(start) = &element.event {
if start.name() == QName(b"iq") {
let mut to: Option<JID> = None;
let mut from: Option<JID> = None;
let mut id = None;
let mut r#type = None;
let mut lang = None;
start
.attributes()
.into_iter()
.try_for_each(|attribute| -> Result<()> {
if let Ok(attribute) = attribute {
let buf: Vec<u8> = Vec::new();
let reader = Reader::from_reader(buf);
match attribute.key {
QName(b"to") => {
to = Some(
attribute
.decode_and_unescape_value(&reader)
.or(Err(JabberError::Utf8Decode))?
.into_owned()
.try_into()?,
)
}
QName(b"from") => {
from = Some(
attribute
.decode_and_unescape_value(&reader)
.or(Err(JabberError::Utf8Decode))?
.into_owned()
.try_into()?,
)
}
QName(b"id") => {
id = Some(
attribute
.decode_and_unescape_value(&reader)
.or(Err(JabberError::Utf8Decode))?
.into_owned(),
)
}
QName(b"type") => {
let value = attribute
.decode_and_unescape_value(&reader)
.or(Err(JabberError::Utf8Decode))?;
match value.as_ref() {
"get" => r#type = Some(IQType::Get),
"set" => r#type = Some(IQType::Set),
"result" => r#type = Some(IQType::Result),
"error" => r#type = Some(IQType::Error),
_ => return Err(JabberError::ParseError),
}
}
QName(b"lang") => {
lang = Some(
attribute
.decode_and_unescape_value(&reader)
.or(Err(JabberError::Utf8Decode))?
.into_owned(),
)
}
_ => return Err(JabberError::UnknownAttribute),
}
}
Ok(())
})?;
let iq = IQ {
to,
from,
id: id.ok_or(JabberError::NoID)?,
r#type: r#type.ok_or(JabberError::NoType)?,
lang,
child: element.child()?.to_owned(),
};
return Ok(iq);
}
}
Err(JabberError::ParseError)
}
}

1
src/stanza/message.rs Normal file
View File

@ -0,0 +1 @@

656
src/stanza/mod.rs
View File

@ -1,657 +1,11 @@
// use quick_xml::events::BytesDecl;
pub mod bind;
pub mod iq;
pub mod message;
pub mod presence;
pub mod sasl;
pub mod starttls;
pub mod stream;
use std::collections::BTreeMap;
use std::str;
use quick_xml::events::{BytesDecl, Event};
// const DECLARATION: BytesDecl<'_> = BytesDecl::new("1.0", None, None);
use async_recursion::async_recursion;
use quick_xml::events::{BytesEnd, BytesStart, BytesText, Event};
use quick_xml::name::PrefixDeclaration;
use quick_xml::{Reader, Writer};
use tokio::io::{AsyncBufRead, AsyncWrite};
use crate::{JabberError, Result};
#[derive(Clone, Debug)]
/// represents an xml element as a tree of nodes
pub struct Element {
/// element prefix
/// e.g. `foo` in `<foo:bar />`.
prefix: Option<String>,
/// element name
/// e.g. `bar` in `<foo:bar />`.
localname: String,
/// qualifying namespace
/// an element must be qualified by a namespace
/// e.g. for `<stream:features>` in
/// ```
/// <stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'>
/// <stream:features>
/// <bind xmlns='urn:ietf:params:xml:ns:xmpp-bind'/>
/// <compression xmlns='http://jabber.org/features/compress'>
/// <method>zlib</method>
/// <method>lzw</method>
/// </compression>
/// </stream:features>
/// </stream:stream>
/// ```
/// would be `"http://etherx.jabber.org/streams"` but for
/// ```
/// <stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'>
/// <features>
/// <bind xmlns='urn:ietf:params:xml:ns:xmpp-bind'/>
/// <compression xmlns='http://jabber.org/features/compress'>
/// <method>zlib</method>
/// <method>lzw</method>
/// </compression>
/// </features>
/// </stream:stream>
/// ```
/// would be `"jabber:client"`
namespace: String,
/// all namespaces applied to element
/// e.g. for `<bind>` in
/// ```
/// <stream:features xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'>
/// <bind xmlns='urn:ietf:params:xml:ns:xmpp-bind'/>
/// <compression xmlns='http://jabber.org/features/compress'>
/// <method>zlib</method>
/// <method>lzw</method>
/// </compression>
/// </stream:features>
/// ```
/// would be `[(None, "urn:ietf:params:xml:ns:xmpp-bind")]` despite
/// `(Some("stream"), "http://etherx.jabber.org/streams")` also being available
// TODO: maybe not even needed, as can calculate when writing which namespaces need to be declared
// but then can't have unused namespace on element, confusing.
namespace_declarations: Box<BTreeMap<Option<String>, String>>,
/// element attributes
attributes: Box<BTreeMap<String, String>>,
// children elements namespaces contain their parents' namespaces
children: Box<Vec<Node>>,
}
#[derive(Clone, Debug)]
pub enum Node {
Element(Element),
Text(String),
Unknown,
}
impl From<Element> for Node {
fn from(element: Element) -> Self {
Self::Element(element)
}
}
impl<S: ToString> From<S> for Node {
fn from(text: S) -> Self {
Self::Text(text.to_string())
}
}
impl<'s> From<&Node> for Vec<Event<'s>> {
fn from(node: &Node) -> Self {
match node {
Node::Element(e) => e.into(),
Node::Text(t) => vec![Event::Text(BytesText::new(t))],
Unknown => vec![],
}
}
}
impl Element {
/// returns the fully qualified name
/// e.g. `foo:bar` in
/// `<foo:bar>`.
pub fn name(&self) -> &str {
if let Some(prefix) = self.prefix {
format!("{}:{}", prefix, self.localname).as_str()
} else {
&self.localname
}
}
/// returns the localname.
/// e.g. `bar` in `<foo:bar>`
pub fn localname(&self) -> &str {
&self.localname
}
/// returns the prefix.
/// e.g. `foo` in `<foo:bar>`. returns None if there is
/// no prefix.
pub fn prefix(&self) -> Option<&str> {
self.prefix
}
/// returns the namespace which applies to the current element, e.g. for
/// `<element xmlns='foo' xmlns:bar='bar'>`
/// it will be `foo` but for
/// `<bar:element xmlns='foo' xmlns:bar='bar'>`
/// it will be `bar`.
pub fn namespace(&self) -> &str {
&self.namespace
}
}
impl<'s> From<&Element> for Vec<Event<'s>> {
fn from(element: &Element) -> Self {
let name = element.name();
let event = BytesStart::new(name);
// namespace declarations
let namespace_declarations = element.namespace_declarations.iter().map(|declaration| {
let (prefix, namespace) = declaration;
match prefix {
Some(prefix) => return (format!("xmlns:{}", prefix).as_str(), *namespace),
None => return ("xmlns", *namespace),
}
});
let event = event.with_attributes(namespace_declarations);
// attributes
let event = event.with_attributes(element.attributes.into_iter());
match element.children.is_empty() {
true => return vec![Event::Empty(event)],
false => {
return {
let start: Vec<Event<'s>> = vec![Event::Start(event)];
let start_and_content: Vec<Event<'s>> = start
.into_iter()
.chain({
let u = element.children.iter().fold(
Vec::new(),
|acc: Vec<Event<'s>>, child: &Node<'s>| {
acc.into_iter()
.chain(Into::<Vec<Event<'s>>>::into(child).into_iter())
.collect()
},
);
u
})
.collect();
let full: Vec<Event<'s>> = start_and_content
.into_iter()
.chain(vec![Event::End(BytesEnd::new(name))])
.collect();
full
}
}
}
}
}
impl Element {
/// if there is only one child in the vec of children, will return that element
pub fn child(&self) -> Result<&Node> {
if self.children.len() == 1 {
Ok(&self.children[0])
} else if self.children.len() > 1 {
Err(ElementError::MultipleChildren.into())
} else {
Err(ElementError::NoChildren.into())
}
}
/// returns reference to children
pub fn children(&self) -> Result<&Vec<Node>> {
if !self.children.is_empty() {
Ok(&self.children)
} else {
Err(ElementError::NoChildren.into())
}
}
/// returns text content, error if there is none
pub fn text_content(&self) -> Result<Vec<&str>> {
let mut text = Vec::new();
for node in *self.children {
match node {
Node::Text(t) => text.push(t),
_ => {}
}
}
if text.is_empty() {
return Err(ElementError::NotText.into());
}
Ok(text)
}
/// returns whether or not the element is qualified by a namespace, either declared
/// by a parent, or itself.
fn namespace_qualified<S: AsRef<str>>(
&self,
namespace_context: &BTreeMap<Option<S>, S>,
) -> bool {
// create a new local_namespaces combining that in the context and those declared within the element
let mut local_namespaces = *namespace_context.clone();
self.namespace_declarations.iter().for_each(|prefix, declaration| local_namespaces.insert(prefix, declaration));
if let Some(namespace) = local_namespaces.get(self.prefix) {
if namespace != self.namespace {
return false;
}
} else {
return false;
};
for child in *self.children {
if child.namespace_qualified(&local_namespaces) == false {
return false;
}
}
true
}
/// writes an element to a writer. the element's namespace must be qualified by the
/// context given in `local_namespaces` or the element's internal namespace declarations
pub async fn write<S: AsRef<str>, W: AsyncWrite + Unpin + Send>(
&self,
writer: &mut Writer<W>,
local_namespaces: &BTreeMap<Option<S>, S>,
) -> Result<()> {
// TODO: instead of having a check if namespace qualified function, have the namespace declarations be added if needed given the context when converting from `Element` to `Event`s
if self.namespace_qualified(local_namespaces) {
let events: Vec<Event> = self.into();
for event in events {
writer.write_event_async(event).await?
}
Ok(())
} else {
Err(ElementError::NamespaceNotQualified.into())
}
}
pub async fn write_start<S: AsRef<str>, W: AsyncWrite + Unpin + Send>(
&self,
writer: &mut Writer<W>,
local_namespaces: &BTreeMap<Option<S>, S>,
) -> Result<()> {
if self.namespace_qualified(local_namespaces) {
let mut event = BytesStart::new(self.name());
// namespace declarations
self.namespace_declarations.iter().for_each(|declaration| {
let (prefix, namespace) = declaration;
match prefix {
Some(prefix) => {
event.push_attribute((format!("xmlns:{}", prefix).as_str(), *namespace))
}
None => event.push_attribute(("xmlns", *namespace)),
}
});
// attributes
let event =
event.with_attributes(self.attributes.iter().map(|(attr, value)| (*attr, *value)));
writer.write_event_async(Event::Start(event)).await?;
Ok(())
} else {
Err(ElementError::NamespaceNotQualified.into())
}
}
pub async fn write_end<W: AsyncWrite + Unpin + Send>(
&self,
writer: &mut Writer<W>,
) -> Result<()> {
let event = BytesEnd::new(self.name());
writer.write_event_async(Event::End(event)).await?;
Ok(())
}
#[async_recursion]
pub async fn read<S: AsRef<str>, R: AsyncBufRead + Unpin + Send>(
reader: &mut Reader<R>,
local_namespaces: &BTreeMap<Option<S>, S>,
) -> Result<Self> {
let node = Node::read_recursive(reader, local_namespaces)
.await?
.ok_or(JabberError::UnexpectedEnd)?;
match node {
Node::Element(e) => Ok(e),
Node::Text(_) => Err(JabberError::UnexpectedText),
Node::Unknown => Err(JabberError::UnexpectedElement),
}
}
pub async fn read_start<S: AsRef<str>, R: AsyncBufRead + Unpin + Send>(
reader: &mut Reader<R>,
local_namespaces: &BTreeMap<Option<S>, S>,
) -> Result<Element> {
let buf = Vec::new();
let event = reader.read_event_into_async(&mut buf).await?;
match event {
Event::Start(e) => {
let prefix = e.name().prefix().map(|prefix| prefix.into_inner());
let converted_prefix;
if let Some(raw_prefix) = prefix {
converted_prefix = Some(str::from_utf8(raw_prefix)?)
}
let prefix = converted_prefix;
let localname = str::from_utf8(e.local_name().into_inner())?.to_owned();
let mut local_namespaces = local_namespaces.clone();
let mut namespace_declarations = BTreeMap::new();
let attributes = BTreeMap::new();
for attribute in e.attributes() {
let attribute = attribute?;
if let Some(prefix_declaration) = attribute.key.as_namespace_binding() {
match prefix_declaration {
PrefixDeclaration::Default => {
let value = str::from_utf8(attribute.value.as_ref())?;
if let Some(_) = namespace_declarations.insert(None, value) {
return Err(ElementParseError::DuplicateAttribute.into());
};
local_namespaces.insert(None, value);
}
PrefixDeclaration::Named(prefix) => {
let key = str::from_utf8(prefix)?;
let value = str::from_utf8(attribute.value.as_ref())?;
if let Some(_) = namespace_declarations.insert(Some(key), value) {
return Err(ElementParseError::DuplicateAttribute.into());
};
local_namespaces.insert(Some(key), value);
}
}
} else {
if let Some(_) = attributes.insert(
str::from_utf8(attribute.key.into_inner())?,
str::from_utf8(attribute.value.as_ref())?,
) {
return Err(ElementParseError::DuplicateAttribute.into());
};
}
}
let namespace = *local_namespaces
.get(&prefix)
.ok_or(ElementParseError::NoNamespace)?;
let mut children = Vec::new();
Ok(Self {
prefix,
localname,
namespace,
namespace_declarations: Box::new(namespace_declarations),
attributes: Box::new(attributes),
children: Box::new(children),
})
}
e => Err(ElementError::NotAStart(e).into()),
}
}
}
impl Node {
#[async_recursion]
async fn read_recursive<S: AsRef<str>, R: AsyncBufRead + Unpin + Send>(
reader: &mut Reader<R>,
local_namespaces: &BTreeMap<Option<S>, S>,
) -> Result<Option<Node>> {
let mut buf = Vec::new();
let event = reader.read_event_into_async(&mut buf).await?;
match event {
Event::Empty(e) => {
let prefix = e.name().prefix().map(|prefix| prefix.into_inner());
let converted_prefix;
if let Some(raw_prefix) = prefix {
converted_prefix = Some(str::from_utf8(raw_prefix)?)
}
let prefix = converted_prefix;
let localname = str::from_utf8(e.local_name().into_inner())?.to_owned();
let mut local_namespaces = local_namespaces.clone();
let mut namespace_declarations = BTreeMap::new();
let attributes = BTreeMap::new();
for attribute in e.attributes() {
let attribute = attribute?;
if let Some(prefix_declaration) = attribute.key.as_namespace_binding() {
match prefix_declaration {
PrefixDeclaration::Default => {
let value = str::from_utf8(attribute.value.as_ref())?;
if let Some(_) = namespace_declarations.insert(None, value) {
return Err(ElementParseError::DuplicateAttribute.into());
};
local_namespaces.insert(None, value);
}
PrefixDeclaration::Named(prefix) => {
let key = str::from_utf8(prefix)?;
let value = str::from_utf8(attribute.value.as_ref())?;
if let Some(_) = namespace_declarations.insert(Some(key), value) {
return Err(ElementParseError::DuplicateAttribute.into());
};
local_namespaces.insert(Some(key), value);
}
}
} else {
if let Some(_) = attributes.insert(
str::from_utf8(attribute.key.into_inner())?,
str::from_utf8(attribute.value.as_ref())?,
) {
return Err(ElementParseError::DuplicateAttribute.into());
};
}
}
let namespace = *local_namespaces
.get(&prefix)
.ok_or(ElementParseError::NoNamespace)?;
let mut children = Vec::new();
Ok(Some(Self::Element(Element {
prefix,
localname,
namespace,
namespace_declarations: Box::new(namespace_declarations),
attributes: Box::new(attributes),
children: Box::new(children),
})))
}
Event::Start(e) => {
let prefix = e.name().prefix().map(|prefix| prefix.into_inner());
let converted_prefix;
if let Some(raw_prefix) = prefix {
converted_prefix = Some(str::from_utf8(raw_prefix)?)
}
let prefix = converted_prefix;
let localname = str::from_utf8(e.local_name().into_inner())?.to_owned();
let mut local_namespaces = local_namespaces.clone();
let mut namespace_declarations = BTreeMap::new();
let attributes = BTreeMap::new();
for attribute in e.attributes() {
let attribute = attribute?;
if let Some(prefix_declaration) = attribute.key.as_namespace_binding() {
match prefix_declaration {
PrefixDeclaration::Default => {
let value = str::from_utf8(attribute.value.as_ref())?;
if let Some(_) = namespace_declarations.insert(None, value) {
return Err(ElementParseError::DuplicateAttribute.into());
};
local_namespaces.insert(None, value);
}
PrefixDeclaration::Named(prefix) => {
let key = str::from_utf8(prefix)?;
let value = str::from_utf8(attribute.value.as_ref())?;
if let Some(_) = namespace_declarations.insert(Some(key), value) {
return Err(ElementParseError::DuplicateAttribute.into());
};
local_namespaces.insert(Some(key), value);
}
}
} else {
if let Some(_) = attributes.insert(
str::from_utf8(attribute.key.into_inner())?,
str::from_utf8(attribute.value.as_ref())?,
) {
return Err(ElementParseError::DuplicateAttribute.into());
};
}
}
let namespace = *local_namespaces
.get(&prefix)
.ok_or(ElementParseError::NoNamespace)?;
let mut children = Vec::new();
while let Some(child_node) = Node::read_recursive(reader, &local_namespaces).await?
{
children.push(child_node)
}
let mut children = Vec::new();
Ok(Some(Self::Element(Element {
prefix,
localname,
namespace,
namespace_declarations: Box::new(namespace_declarations),
attributes: Box::new(attributes),
children: Box::new(children),
})))
}
Event::End(_) => Ok(None),
Event::Text(e) => Ok(Some(Self::Text(e.unescape()?.as_ref().to_string()))),
e => Ok(Some(Self::Unknown)),
}
}
fn namespace_qualified<S: AsRef<str>>(
&self,
namespace_context: &BTreeMap<Option<S>, S>,
) -> bool {
match self {
Self::Element(e) => e.namespace_qualified(namespace_context),
_ => true,
}
}
}
pub enum NodeBuilder {
Text(String),
Element(ElementBuilder),
}
pub struct ElementBuilder {
localname: String,
prefix: Option<String>,
namespace: String,
namespace_declarations: BTreeMap<Option<String>, String>,
attributes: BTreeMap<String, String>,
children: Vec<NodeBuilder>,
}
impl ElementBuilder {
pub fn new<S: ToString>(localname: S, prefix: Option<S>, namespace: S) -> Self {
Self {
prefix,
localname,
namespace,
namespace_declarations: Box::new(BTreeMap::new()),
attributes: Box::new(BTreeMap::new()),
children: Box::new(Vec::new()),
}
}
pub fn push_namespace_declaration<S: ToString>(
&mut self,
(prefix, namespace): (Option<S>, S),
) -> Option<S> {
self.namespace_declarations.insert(prefix, namespace)
}
pub fn push_attribute<S: ToString>(&mut self, (key, value): (S, S)) -> Option<S> {
self.attributes.insert(key, value)
}
pub fn push_child(&mut self, child: Node) {
self.children.push(child)
}
/// checks if there is a namespace conflict within the element being built
pub fn namespace_conflict<S: AsRef<str>>(
&self
) -> bool {
self.namespace_conflict_recursive(&BTreeMap::new())
}
fn namespace_conflict_recursive<S: AsRef<str>>(
&self,
parent_namespaces: &BTreeMap<Option<S>, S>,
) -> bool {
// create a new local_namespaces combining that in the context and those declared within the element
let mut local_namespaces = *parent_namespaces.clone();
self.namespace_declarations.iter().for_each(|prefix, declaration| local_namespaces.insert(prefix, declaration));
if let Some(namespace) = local_namespaces.get(self.prefix) {
if namespace != self.namespace {
return false;
}
} else {
return false;
};
for child in *self.children {
if child.namespace_conflict(&local_namespaces) == false {
return false;
}
}
true
}
// check for possible conflicts in namespace
pub fn build(self) -> Result<Element> {
for child in self.children {
match child {
Node::Element(e) => {
if !e.namespace_conflict()
}
}
}
Element {
prefix: self.prefix,
localname: self.localname,
namespace: self.namespace,
namespace_declarations: self.namespace_declarations,
attributes: self.attributes,
children: self.children,
}
}
}
#[derive(Debug)]
pub enum ElementError<'e> {
NotAStart(Event<'e>),
NotText,
NoChildren,
NamespaceNotQualified,
MultipleChildren,
}
#[derive(Debug)]
pub enum ElementParseError {
DuplicateAttribute,
NoNamespace,
}
pub static DECLARATION: Event = Event::Decl(BytesDecl::new("1.0", None, None));

1
src/stanza/presence.rs Normal file
View File

@ -0,0 +1 @@

144
src/stanza/sasl.rs
View File

@ -1,145 +1 @@
use quick_xml::{
events::{BytesStart, BytesText, Event},
name::QName,
};
use crate::error::SASLError;
use crate::JabberError;
use super::Element;
const XMLNS: &str = "urn:ietf:params:xml:ns:xmpp-sasl";
#[derive(Debug)]
pub struct Auth<'e> {
pub mechanism: &'e str,
pub sasl_data: &'e str,
}
impl<'e> IntoElement<'e> for Auth<'e> {
fn event(&self) -> Event<'e> {
let mut start = BytesStart::new("auth");
start.push_attribute(("xmlns", XMLNS));
start.push_attribute(("mechanism", self.mechanism));
Event::Start(start)
}
fn children(&self) -> Option<Vec<Element<'e>>> {
let sasl = BytesText::from_escaped(self.sasl_data);
let sasl = Element {
event: Event::Text(sasl),
children: None,
};
Some(vec![sasl])
}
}
#[derive(Debug)]
pub struct Challenge {
pub sasl_data: Vec<u8>,
}
impl<'e> TryFrom<&Element<'e>> for Challenge {
type Error = JabberError;
fn try_from(element: &Element<'e>) -> Result<Challenge, Self::Error> {
if let Event::Start(start) = &element.event {
if start.name() == QName(b"challenge") {
let sasl_data: &Element<'_> = element.child()?;
if let Event::Text(sasl_data) = &sasl_data.event {
let s = sasl_data.clone();
let s = s.into_inner();
let s = s.to_vec();
return Ok(Challenge { sasl_data: s });
}
}
}
Err(SASLError::NoChallenge.into())
}
}
// impl<'e> TryFrom<Element<'e>> for Challenge {
// type Error = JabberError;
// fn try_from(element: Element<'e>) -> Result<Challenge, Self::Error> {
// if let Event::Start(start) = &element.event {
// if start.name() == QName(b"challenge") {
// println!("one");
// if let Some(children) = element.children.as_deref() {
// if children.len() == 1 {
// let sasl_data = children.first().unwrap();
// if let Event::Text(sasl_data) = &sasl_data.event {
// return Ok(Challenge {
// sasl_data: sasl_data.clone().into_inner().to_vec(),
// });
// } else {
// return Err(SASLError::NoChallenge.into());
// }
// } else {
// return Err(SASLError::NoChallenge.into());
// }
// } else {
// return Err(SASLError::NoChallenge.into());
// }
// }
// }
// Err(SASLError::NoChallenge.into())
// }
// }
#[derive(Debug)]
pub struct Response<'e> {
pub sasl_data: &'e str,
}
impl<'e> IntoElement<'e> for Response<'e> {
fn event(&self) -> Event<'e> {
let mut start = BytesStart::new("response");
start.push_attribute(("xmlns", XMLNS));
Event::Start(start)
}
fn children(&self) -> Option<Vec<Element<'e>>> {
let sasl = BytesText::from_escaped(self.sasl_data);
let sasl = Element {
event: Event::Text(sasl),
children: None,
};
Some(vec![sasl])
}
}
#[derive(Debug)]
pub struct Success {
pub sasl_data: Option<Vec<u8>>,
}
impl<'e> TryFrom<&Element<'e>> for Success {
type Error = JabberError;
fn try_from(element: &Element<'e>) -> Result<Success, Self::Error> {
match &element.event {
Event::Start(start) => {
if start.name() == QName(b"success") {
match element.child() {
Ok(sasl_data) => {
if let Event::Text(sasl_data) = &sasl_data.event {
return Ok(Success {
sasl_data: Some(sasl_data.clone().into_inner().to_vec()),
});
}
}
Err(_) => return Ok(Success { sasl_data: None }),
};
}
}
Event::Empty(empty) => {
if empty.name() == QName(b"success") {
return Ok(Success { sasl_data: None });
}
}
_ => {}
}
Err(SASLError::NoSuccess.into())
}
}

1
src/stanza/starttls.rs Normal file
View File

@ -0,0 +1 @@

220
src/stanza/stream.rs
View File

@ -1,190 +1,60 @@
use std::str;
use serde::Serialize;
use quick_xml::{
events::{BytesStart, Event},
name::QName,
};
use crate::JID;
use super::Element;
use crate::{JabberError, Result, JID};
pub static XMLNS: &str = "http://etherx.jabber.org/streams";
pub static XMLNS_CLIENT: &str = "jabber:client";
const XMLNS_STREAM: &str = "http://etherx.jabber.org/streams";
const VERSION: &str = "1.0";
enum XMLNS {
Client,
Server,
}
impl From<XMLNS> for &str {
fn from(xmlns: XMLNS) -> Self {
match xmlns {
XMLNS::Client => return "jabber:client",
XMLNS::Server => return "jabber:server",
}
}
}
impl TryInto<XMLNS> for &str {
type Error = JabberError;
fn try_into(self) -> Result<XMLNS> {
match self {
"jabber:client" => Ok(XMLNS::Client),
"jabber:server" => Ok(XMLNS::Server),
_ => Err(JabberError::UnknownNamespace),
}
}
}
pub struct Stream {
from: Option<JID>,
id: Option<String>,
to: Option<JID>,
version: Option<String>,
lang: Option<String>,
ns: XMLNS,
// MUST be qualified by stream namespace
#[derive(Serialize)]
pub struct Stream<'s> {
#[serde(rename = "@from")]
from: Option<&'s JID>,
#[serde(rename = "@to")]
to: Option<&'s JID>,
#[serde(rename = "@id")]
id: Option<&'s str>,
#[serde(rename = "@version")]
version: Option<&'s str>,
// TODO: lang enum
#[serde(rename = "@lang")]
lang: Option<&'s str>,
#[serde(rename = "@xmlns")]
xmlns: &'s str,
#[serde(rename = "@xmlns:stream")]
xmlns_stream: &'s str,
}
impl Stream {
pub fn new_client(from: &JID, to: &JID, id: Option<String>, lang: Option<String>) -> Self {
pub fn new(
from: Option<&JID>,
to: Option<&JID>,
id: Option<&str>,
version: Option<&str>,
lang: Option<&str>,
) -> Self {
Self {
from: Some(from.clone()),
from,
to,
id,
to: Some(to.clone()),
version: Some(VERSION.to_owned()),
version,
lang,
ns: XMLNS::Client,
xmlns: XMLNS_CLIENT,
xmlns_stream: XMLNS,
}
}
fn event(&self) -> Event<'static> {
let mut start = BytesStart::new("stream:stream");
if let Some(from) = &self.from {
start.push_attribute(("from", from.to_string().as_str()));
}
if let Some(id) = &self.id {
start.push_attribute(("id", id.as_str()));
}
if let Some(to) = &self.to {
start.push_attribute(("to", to.to_string().as_str()));
}
if let Some(version) = &self.version {
start.push_attribute(("version", version.to_string().as_str()));
}
if let Some(lang) = &self.lang {
start.push_attribute(("xml:lang", lang.as_str()));
}
match &self.ns {
XMLNS::Client => start.push_attribute(("xmlns", XMLNS::Client.into())),
XMLNS::Server => start.push_attribute(("xmlns", XMLNS::Server.into())),
}
start.push_attribute(("xmlns:stream", XMLNS_STREAM));
Event::Start(start)
}
}
impl<'e> Into<Element<'e>> for Stream {
fn into(self) -> Element<'e> {
Element {
event: self.event(),
children: None,
/// For initial stream headers, the initiating entity SHOULD include the 'xml:lang' attribute.
/// For privacy, it is better to not set `from` when sending a client stanza over an unencrypted connection.
pub fn new_client(from: Option<&JID>, to: &JID, id: Option<&str>, lang: &str) -> Self {
Self {
from,
to: Some(to),
id,
version: Some("1.0"),
lang: Some(lang),
xmlns: XMLNS_CLIENT,
xmlns_stream: XMLNS,
}
}
}
impl<'e> TryFrom<Element<'e>> for Stream {
type Error = JabberError;
fn try_from(value: Element<'e>) -> Result<Stream> {
let (mut from, mut id, mut to, mut version, mut lang, mut ns) =
(None, None, None, None, None, XMLNS::Client);
if let Event::Start(e) = value.event.as_ref() {
for attribute in e.attributes() {
let attribute = attribute?;
match attribute.key {
QName(b"from") => {
from = Some(str::from_utf8(&attribute.value)?.to_string().try_into()?);
}
QName(b"id") => {
id = Some(str::from_utf8(&attribute.value)?.to_owned());
}
QName(b"to") => {
to = Some(str::from_utf8(&attribute.value)?.to_string().try_into()?);
}
QName(b"version") => {
version = Some(str::from_utf8(&attribute.value)?.to_owned());
}
QName(b"lang") => {
lang = Some(str::from_utf8(&attribute.value)?.to_owned());
}
QName(b"xmlns") => {
ns = str::from_utf8(&attribute.value)?.try_into()?;
}
_ => {
println!("unknown attribute: {:?}", attribute)
}
}
}
Ok(Stream {
from,
id,
to,
version,
lang,
ns,
})
} else {
Err(JabberError::ParseError)
}
}
}
#[derive(PartialEq, Debug)]
pub enum StreamFeature {
StartTls,
Sasl(Vec<String>),
Bind,
Unknown,
}
impl<'e> TryFrom<Element<'e>> for Vec<StreamFeature> {
type Error = JabberError;
fn try_from(features_element: Element) -> Result<Self> {
let mut features = Vec::new();
if let Some(children) = features_element.children {
for feature_element in children {
match feature_element.event {
Event::Start(e) => match e.name() {
QName(b"starttls") => features.push(StreamFeature::StartTls),
QName(b"mechanisms") => {
let mut mechanisms = Vec::new();
if let Some(children) = feature_element.children {
for mechanism_element in children {
if let Some(children) = mechanism_element.children {
for mechanism_text in children {
match mechanism_text.event {
Event::Text(e) => mechanisms
.push(str::from_utf8(e.as_ref())?.to_owned()),
_ => {}
}
}
}
}
}
features.push(StreamFeature::Sasl(mechanisms))
}
_ => features.push(StreamFeature::Unknown),
},
Event::Empty(e) => match e.name() {
QName(b"bind") => features.push(StreamFeature::Bind),
_ => features.push(StreamFeature::Unknown),
},
_ => features.push(StreamFeature::Unknown),
}
}
}
Ok(features)
}
}