forked from lavina/lavina
1
0
Fork 0
lavina/src/protos/xmpp/client.rs

313 lines
11 KiB
Rust
Raw Normal View History

2023-03-07 13:56:31 +00:00
use quick_xml::events::Event;
2023-03-11 15:07:02 +00:00
use quick_xml::name::ResolveResult;
2023-03-07 13:56:31 +00:00
use crate::prelude::*;
use crate::util::xml::*;
pub static XMLNS: &'static str = "jabber:client";
2023-03-07 13:56:31 +00:00
#[derive(PartialEq, Eq, Debug)]
pub struct Message {
pub from: Option<String>,
pub id: Option<String>,
pub to: Option<String>,
2023-03-07 13:56:31 +00:00
// default is Normal
pub r#type: MessageType,
pub lang: Option<String>,
2023-03-07 13:56:31 +00:00
pub subject: Option<String>,
pub body: String,
2023-03-07 13:56:31 +00:00
}
impl Message {
pub fn parse() -> impl Parser<Output = Result<Self>> {
MessageParser::Init
}
}
#[derive(Default)]
enum MessageParser {
#[default]
Init,
Outer(MessageParserState),
InSubject(MessageParserState),
InBody(MessageParserState),
}
#[derive(Default)]
struct MessageParserState {
from: Option<String>,
id: Option<String>,
to: Option<String>,
r#type: MessageType,
lang: Option<String>,
subject: Option<String>,
body: Option<String>,
}
impl Parser for MessageParser {
type Output = Result<Message>;
2023-03-11 15:07:02 +00:00
fn consume<'a>(
self: Self,
namespace: ResolveResult,
event: &Event<'a>,
) -> Continuation<Self, Self::Output> {
2023-03-07 13:56:31 +00:00
// TODO validate tag name and namespace at each stage
match self {
MessageParser::Init => {
if let Event::Start(ref bytes) = event {
let mut state: MessageParserState = Default::default();
for attr in bytes.attributes() {
let attr = fail_fast!(attr);
if attr.key.0 == b"from" {
let value = fail_fast!(std::str::from_utf8(&*attr.value));
state.from = Some(value.to_string())
} else if attr.key.0 == b"id" {
let value = fail_fast!(std::str::from_utf8(&*attr.value));
state.id = Some(value.to_string())
} else if attr.key.0 == b"to" {
let value = fail_fast!(std::str::from_utf8(&*attr.value));
state.to = Some(value.to_string())
} else if attr.key.0 == b"type" {
let value = fail_fast!(MessageType::from_str(&*attr.value));
state.r#type = value;
2023-03-07 13:56:31 +00:00
}
}
Continuation::Continue(MessageParser::Outer(state))
} else {
Continuation::Final(Err(ffail!("Expected start")))
}
}
MessageParser::Outer(state) => match event {
Event::Start(ref bytes) => {
if bytes.name().0 == b"subject" {
Continuation::Continue(MessageParser::InSubject(state))
} else if bytes.name().0 == b"body" {
Continuation::Continue(MessageParser::InBody(state))
} else {
Continuation::Final(Err(ffail!("Unexpected XML tag")))
2023-03-07 13:56:31 +00:00
}
}
Event::End(_) => {
if let Some(body) = state.body {
Continuation::Final(Ok(Message {
from: state.from,
id: state.id,
to: state.to,
r#type: state.r#type,
lang: state.lang,
subject: state.subject,
body,
}))
} else {
Continuation::Final(Err(ffail!("Body not found")))
2023-03-07 13:56:31 +00:00
}
}
_ => Continuation::Final(Err(ffail!("Unexpected XML event: {event:?}"))),
2023-03-07 13:56:31 +00:00
},
MessageParser::InSubject(mut state) => match event {
Event::Text(ref bytes) => {
let subject = fail_fast!(std::str::from_utf8(&*bytes));
state.subject = Some(subject.to_string());
Continuation::Continue(MessageParser::InSubject(state))
2023-03-07 13:56:31 +00:00
}
Event::End(_) => Continuation::Continue(MessageParser::Outer(state)),
_ => Continuation::Final(Err(ffail!("Unexpected XML event: {event:?}"))),
},
MessageParser::InBody(mut state) => match event {
Event::Text(ref bytes) => match std::str::from_utf8(&*bytes) {
Ok(subject) => {
state.body = Some(subject.to_string());
Continuation::Continue(MessageParser::InBody(state))
2023-03-07 13:56:31 +00:00
}
Err(err) => Continuation::Final(Err(err.into())),
},
Event::End(_) => Continuation::Continue(MessageParser::Outer(state)),
_ => Continuation::Final(Err(ffail!("Unexpected XML event: {event:?}"))),
},
2023-03-07 13:56:31 +00:00
}
}
}
#[derive(PartialEq, Eq, Debug)]
pub enum MessageType {
Chat,
Error,
Groupchat,
Headline,
Normal,
}
impl Default for MessageType {
fn default() -> Self {
MessageType::Normal
}
}
impl MessageType {
pub fn from_str(s: &[u8]) -> Result<MessageType> {
2023-03-07 13:56:31 +00:00
use MessageType::*;
let s = std::str::from_utf8(s)?;
2023-03-07 13:56:31 +00:00
match s {
"chat" => Ok(Chat),
"error" => Ok(Error),
"groupchat" => Ok(Groupchat),
"headline" => Ok(Headline),
"normal" => Ok(Normal),
t => Err(ffail!("Unknown message type: {t}")),
}
}
}
2023-03-08 18:56:53 +00:00
pub struct Iq<T> {
pub from: Option<String>,
pub id: String,
pub to: Option<String>,
pub r#type: IqType,
pub body: T,
}
impl<T: FromXml> FromXml for Iq<T> {
type P = IqParser<T>;
fn parse() -> Self::P {
IqParser(IqParserInner::Init)
}
}
pub struct IqParser<T: FromXml>(IqParserInner<T>);
enum IqParserInner<T: FromXml> {
Init,
ParsingBody(IqParserState<T>, T::P),
Final(IqParserState<T>),
}
struct IqParserState<T> {
pub from: Option<String>,
pub id: Option<String>,
pub to: Option<String>,
pub r#type: Option<IqType>,
pub body: Option<T>,
}
impl<T: FromXml> Parser for IqParser<T> {
type Output = Result<Iq<T>>;
2023-03-11 15:07:02 +00:00
fn consume<'a>(
self: Self,
namespace: ResolveResult,
event: &Event<'a>,
) -> Continuation<Self, Self::Output> {
2023-03-08 18:56:53 +00:00
match self.0 {
IqParserInner::Init => {
if let Event::Start(ref bytes) = event {
let mut state: IqParserState<T> = IqParserState { from: None, id: None, to: None, r#type: None, body: None };
for attr in bytes.attributes() {
let attr = fail_fast!(attr);
if attr.key.0 == b"from" {
let value = fail_fast!(std::str::from_utf8(&*attr.value));
state.from = Some(value.to_string())
} else if attr.key.0 == b"id" {
let value = fail_fast!(std::str::from_utf8(&*attr.value));
state.id = Some(value.to_string())
} else if attr.key.0 == b"to" {
let value = fail_fast!(std::str::from_utf8(&*attr.value));
state.to = Some(value.to_string())
} else if attr.key.0 == b"type" {
let value = fail_fast!(IqType::from_str(&*attr.value));
state.r#type = Some(value);
}
}
Continuation::Continue(IqParser(IqParserInner::ParsingBody(state, T::parse())))
} else {
Continuation::Final(Err(ffail!("Expected start")))
}
}
IqParserInner::ParsingBody(mut state, parser) => {
2023-03-11 15:07:02 +00:00
match parser.consume(namespace, event) {
2023-03-08 18:56:53 +00:00
Continuation::Final(f) => {
let body = fail_fast!(f);
state.body = Some(body);
Continuation::Continue(IqParser(IqParserInner::Final(state)))
}
Continuation::Continue(parser) => {
Continuation::Continue(IqParser(IqParserInner::ParsingBody(state, parser)))
}
}
}
IqParserInner::Final(state) => {
if let Event::End(ref bytes) = event {
let id = fail_fast!(state.id.ok_or_else(|| fail("No id provided")));
let r#type = fail_fast!(state.r#type.ok_or_else(|| fail("No type provided")));
let body = fail_fast!(state.body.ok_or_else(|| fail("No body provided")));
Continuation::Final(Ok(Iq {
from: state.from,
id,
to: state.to,
r#type,
body,
}))
} else {
Continuation::Final(Err(ffail!("Unexpected event: {event:?}")))
}
}
}
}
}
pub enum IqType {
Error,
Get,
Result,
Set,
}
impl IqType {
pub fn from_str(s: &[u8]) -> Result<IqType> {
use IqType::*;
let s = std::str::from_utf8(s)?;
match s {
"error" => Ok(Error),
"get" => Ok(Get),
"result" => Ok(Result),
"set" => Ok(Set),
t => Err(ffail!("Unknown iq type: {t}")),
}
}
}
2023-03-07 13:56:31 +00:00
#[cfg(test)]
mod tests {
use super::*;
use quick_xml::NsReader;
#[tokio::test]
async fn parse_message() {
let input = r#"<message id="aacea" type="chat" to="nikita@vlnv.dev"><subject>daa</subject><body>bbb</body></message>"#;
let mut reader = NsReader::from_reader(input.as_bytes());
let mut buf = vec![];
2023-03-11 15:07:02 +00:00
let (ns, event) = reader.read_resolved_event_into_async(&mut buf).await.unwrap();
let mut parser = Message::parse().consume(ns, &event);
2023-03-07 13:56:31 +00:00
let result = loop {
match parser {
Continuation::Final(res) => break res,
Continuation::Continue(next) => {
2023-03-11 15:07:02 +00:00
let (ns, event) = reader.read_resolved_event_into_async(&mut buf).await.unwrap();
parser = next.consume(ns, &event);
2023-03-07 13:56:31 +00:00
}
}
}
.unwrap();
assert_eq!(
result,
Message {
from: None,
id: Some("aacea".to_string()),
to: Some("nikita@vlnv.dev".to_string()),
r#type: MessageType::Chat,
2023-03-07 13:56:31 +00:00
lang: None,
subject: Some("daa".to_string()),
body: "bbb".to_string(),
}
)
}
}