forked from lavina/lavina
124 lines
3.6 KiB
Rust
124 lines
3.6 KiB
Rust
use derive_more::From;
|
|
use quick_xml::events::Event;
|
|
use quick_xml::name::{Namespace, ResolveResult};
|
|
|
|
use crate::protos::xmpp::bind::BindRequest;
|
|
use crate::protos::xmpp::client::{Iq, Message, Presence};
|
|
use crate::protos::xmpp::roster::RosterQuery;
|
|
use crate::protos::xmpp::session::Session;
|
|
use crate::util::xml::*;
|
|
|
|
use crate::prelude::*;
|
|
|
|
#[derive(PartialEq, Eq, Debug, From)]
|
|
pub enum IqClientBody {
|
|
Bind(BindRequest),
|
|
Session(Session),
|
|
Roster(RosterQuery),
|
|
}
|
|
|
|
#[derive(From)]
|
|
pub struct IqClientBodyParser(IqClientBodyParserInner);
|
|
|
|
#[derive(From)]
|
|
enum IqClientBodyParserInner {
|
|
Initial,
|
|
Bind(<BindRequest as FromXml>::P),
|
|
SessionV(<Session as FromXml>::P),
|
|
RosterV(<RosterQuery as FromXml>::P),
|
|
}
|
|
|
|
impl FromXml for IqClientBody {
|
|
type P = IqClientBodyParser;
|
|
|
|
fn parse() -> Self::P {
|
|
IqClientBodyParserInner::Initial.into()
|
|
}
|
|
}
|
|
|
|
impl Parser for IqClientBodyParser {
|
|
type Output = Result<IqClientBody>;
|
|
|
|
fn consume<'a>(
|
|
self: Self,
|
|
namespace: quick_xml::name::ResolveResult,
|
|
event: &quick_xml::events::Event<'a>,
|
|
) -> crate::util::xml::Continuation<Self, Self::Output> {
|
|
use IqClientBodyParserInner::*;
|
|
match self.0 {
|
|
Initial => {
|
|
let bytes = match event {
|
|
Event::Start(bytes) => bytes,
|
|
Event::Empty(bytes) => bytes,
|
|
_ => {
|
|
return Continuation::Final(Err(ffail!("Unexpected XML event: {event:?}")))
|
|
}
|
|
};
|
|
let name = bytes.name();
|
|
match_parser!(IqClientBodyParser, name, namespace, event;
|
|
BindRequest,
|
|
Session,
|
|
RosterQuery
|
|
)
|
|
}
|
|
Bind(p) => delegate_parsing!(p, IqClientBodyParserInner, namespace, event),
|
|
SessionV(p) => delegate_parsing!(p, IqClientBodyParserInner, namespace, event),
|
|
RosterV(p) => delegate_parsing!(p, IqClientBodyParserInner, namespace, event),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(PartialEq, Eq, Debug, From)]
|
|
pub enum ClientPacket {
|
|
Iq(Iq<IqClientBody>),
|
|
Message(Message),
|
|
Presence(Presence),
|
|
}
|
|
|
|
#[derive(From)]
|
|
pub struct ClientPacketParser(ClientPacketParserInner);
|
|
|
|
impl FromXml for ClientPacket {
|
|
type P = ClientPacketParser;
|
|
|
|
fn parse() -> Self::P {
|
|
ClientPacketParserInner::Initial.into()
|
|
}
|
|
}
|
|
|
|
#[derive(From)]
|
|
enum ClientPacketParserInner {
|
|
Initial,
|
|
IqV(<Iq<IqClientBody> as FromXml>::P),
|
|
MessageV(<Message as FromXml>::P),
|
|
PresenceV(<Presence as FromXml>::P),
|
|
}
|
|
|
|
impl Parser for ClientPacketParser {
|
|
type Output = Result<ClientPacket>;
|
|
|
|
fn consume<'a>(
|
|
self: Self,
|
|
namespace: ResolveResult,
|
|
event: &Event<'a>,
|
|
) -> Continuation<Self, Self::Output> {
|
|
use ClientPacketParserInner::*;
|
|
match self.0 {
|
|
Initial => {
|
|
let Event::Start(bytes) = event else {
|
|
return Continuation::Final(Err(ffail!("Unexpected XML event: {event:?}")));
|
|
};
|
|
let name = bytes.name();
|
|
match_parser!(ClientPacketParser, name, namespace, event;
|
|
Iq::<IqClientBody>,
|
|
Presence,
|
|
Message
|
|
)
|
|
}
|
|
IqV(p) => delegate_parsing!(p, ClientPacketParserInner, namespace, event),
|
|
MessageV(p) => delegate_parsing!(p, ClientPacketParserInner, namespace, event),
|
|
PresenceV(p) => delegate_parsing!(p, ClientPacketParserInner, namespace, event),
|
|
}
|
|
}
|
|
}
|