xmpp-rs/src/iq.rs
2017-04-28 23:46:06 +01:00

299 lines
9.5 KiB
Rust

use minidom::Element;
use minidom::IntoAttributeValue;
use jid::Jid;
use error::Error;
use ns;
use disco;
use jingle;
use ping;
/// Lists every known payload of a `<iq/>`.
#[derive(Debug, Clone)]
pub enum IqPayload {
Disco(disco::Disco),
Jingle(jingle::Jingle),
Ping(ping::Ping),
}
#[derive(Debug, Clone)]
pub enum IqPayloadType {
XML(Element),
Parsed(IqPayload),
}
#[derive(Debug, Clone)]
pub enum IqType {
Get(IqPayloadType),
Set(IqPayloadType),
Result(Option<IqPayloadType>),
Error(IqPayloadType),
}
impl IntoAttributeValue for IqType {
fn into_attribute_value(self) -> Option<String> {
Some(match self {
IqType::Get(_) => "get",
IqType::Set(_) => "set",
IqType::Result(_) => "result",
IqType::Error(_) => "error",
}.to_owned())
}
}
#[derive(Debug, Clone)]
pub struct Iq {
pub from: Option<Jid>,
pub to: Option<Jid>,
pub id: Option<String>,
pub payload: IqType,
}
pub fn parse_iq(root: &Element) -> Result<Iq, Error> {
if !root.is("iq", ns::JABBER_CLIENT) {
return Err(Error::ParseError("This is not an iq element."));
}
let from = root.attr("from")
.and_then(|value| value.parse().ok());
let to = root.attr("to")
.and_then(|value| value.parse().ok());
let id = root.attr("id")
.and_then(|value| value.parse().ok());
let type_ = match root.attr("type") {
Some(type_) => type_,
None => return Err(Error::ParseError("Iq element requires a 'type' attribute.")),
};
let mut payload = None;
for elem in root.children() {
if payload.is_some() {
return Err(Error::ParseError("Wrong number of children in iq element."));
}
if type_ == "error" {
if elem.is("error", ns::JABBER_CLIENT) {
payload = Some(IqPayloadType::XML(elem.clone()));
} else if root.children().collect::<Vec<_>>().len() != 2 {
return Err(Error::ParseError("Wrong number of children in iq element."));
}
} else {
let parsed_payload = if let Ok(disco) = disco::parse_disco(elem) {
Some(IqPayload::Disco(disco))
} else if let Ok(jingle) = jingle::parse_jingle(elem) {
Some(IqPayload::Jingle(jingle))
} else if let Ok(ping) = ping::parse_ping(elem) {
Some(IqPayload::Ping(ping))
} else {
None
};
payload = match parsed_payload {
Some(payload) => Some(IqPayloadType::Parsed(payload)),
None => Some(IqPayloadType::XML(elem.clone())),
};
}
}
let type_ = if type_ == "get" {
if let Some(payload) = payload.clone() {
IqType::Get(payload.clone())
} else {
return Err(Error::ParseError("Wrong number of children in iq element."));
}
} else if type_ == "set" {
if let Some(payload) = payload.clone() {
IqType::Set(payload.clone())
} else {
return Err(Error::ParseError("Wrong number of children in iq element."));
}
} else if type_ == "result" {
if let Some(payload) = payload.clone() {
IqType::Result(Some(payload.clone()))
} else {
IqType::Result(None)
}
} else if type_ == "error" {
if let Some(payload) = payload.clone() {
IqType::Error(payload.clone())
} else {
return Err(Error::ParseError("Wrong number of children in iq element."));
}
} else {
panic!()
};
Ok(Iq {
from: from,
to: to,
id: id,
payload: type_,
})
}
pub fn serialise_payload(payload: &IqPayload) -> Element {
match *payload {
IqPayload::Disco(ref disco) => disco::serialise_disco(disco),
IqPayload::Jingle(ref jingle) => jingle::serialise(jingle),
IqPayload::Ping(_) => ping::serialise_ping(),
}
}
pub fn serialise(iq: &Iq) -> Element {
let mut stanza = Element::builder("iq")
.ns(ns::JABBER_CLIENT)
.attr("from", iq.from.clone().and_then(|value| Some(String::from(value))))
.attr("to", iq.to.clone().and_then(|value| Some(String::from(value))))
.attr("id", iq.id.clone())
.attr("type", iq.payload.clone())
.build();
let elem = match iq.payload.clone() {
IqType::Get(IqPayloadType::XML(elem))
| IqType::Set(IqPayloadType::XML(elem))
| IqType::Result(Some(IqPayloadType::XML(elem)))
| IqType::Error(IqPayloadType::XML(elem)) => elem,
IqType::Get(IqPayloadType::Parsed(payload))
| IqType::Set(IqPayloadType::Parsed(payload))
| IqType::Result(Some(IqPayloadType::Parsed(payload))) => serialise_payload(&payload),
IqType::Result(None) => return stanza,
_ => panic!(),
};
stanza.append_child(elem);
stanza
}
#[cfg(test)]
mod tests {
use minidom::Element;
use error::Error;
use iq;
use disco;
#[test]
fn test_require_type() {
let elem: Element = "<iq xmlns='jabber:client'/>".parse().unwrap();
let error = iq::parse_iq(&elem).unwrap_err();
let message = match error {
Error::ParseError(string) => string,
_ => panic!(),
};
assert_eq!(message, "Iq element requires a 'type' attribute.");
}
#[test]
fn test_get() {
let elem: Element = "<iq xmlns='jabber:client' type='get'>
<foo/>
</iq>".parse().unwrap();
let iq = iq::parse_iq(&elem).unwrap();
let query: Element = "<foo xmlns='jabber:client'/>".parse().unwrap();
assert_eq!(iq.from, None);
assert_eq!(iq.to, None);
assert_eq!(iq.id, None);
assert!(match iq.payload {
iq::IqType::Get(iq::IqPayloadType::XML(element)) => element == query,
_ => false
});
}
#[test]
fn test_set() {
let elem: Element = "<iq xmlns='jabber:client' type='set'>
<vCard xmlns='vcard-temp'/>
</iq>".parse().unwrap();
let iq = iq::parse_iq(&elem).unwrap();
let vcard: Element = "<vCard xmlns='vcard-temp'/>".parse().unwrap();
assert_eq!(iq.from, None);
assert_eq!(iq.to, None);
assert_eq!(iq.id, None);
assert!(match iq.payload {
iq::IqType::Set(iq::IqPayloadType::XML(element)) => element == vcard,
_ => false
});
}
#[test]
fn test_result_empty() {
let elem: Element = "<iq xmlns='jabber:client' type='result'/>".parse().unwrap();
let iq = iq::parse_iq(&elem).unwrap();
assert_eq!(iq.from, None);
assert_eq!(iq.to, None);
assert_eq!(iq.id, None);
assert!(match iq.payload {
iq::IqType::Result(None) => true,
_ => false,
});
}
#[test]
fn test_result() {
let elem: Element = "<iq xmlns='jabber:client' type='result'>
<query xmlns='http://jabber.org/protocol/disco#items'/>
</iq>".parse().unwrap();
let iq = iq::parse_iq(&elem).unwrap();
let query: Element = "<query xmlns='http://jabber.org/protocol/disco#items'/>".parse().unwrap();
assert_eq!(iq.from, None);
assert_eq!(iq.to, None);
assert_eq!(iq.id, None);
assert!(match iq.payload {
iq::IqType::Result(Some(iq::IqPayloadType::XML(element))) => element == query,
_ => false,
});
}
#[test]
fn test_error() {
let elem: Element = "<iq xmlns='jabber:client' type='error'>
<ping xmlns='urn:xmpp:ping'/>
<error type='cancel'>
<service-unavailable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>
</error>
</iq>".parse().unwrap();
let iq = iq::parse_iq(&elem).unwrap();
let error: Element = "<error xmlns='jabber:client' type='cancel'>
<service-unavailable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>
</error>".parse().unwrap();
assert_eq!(iq.from, None);
assert_eq!(iq.to, None);
assert_eq!(iq.id, None);
assert!(match iq.payload {
iq::IqType::Error(iq::IqPayloadType::XML(element)) => element == error,
_ => false,
});
}
#[test]
fn test_children_invalid() {
let elem: Element = "<iq xmlns='jabber:client' type='error'></iq>".parse().unwrap();
let error = iq::parse_iq(&elem).unwrap_err();
let message = match error {
Error::ParseError(string) => string,
_ => panic!(),
};
assert_eq!(message, "Wrong number of children in iq element.");
}
#[test]
fn test_serialise() {
let elem: Element = "<iq xmlns='jabber:client' type='result'/>".parse().unwrap();
let iq2 = iq::Iq {
from: None,
to: None,
id: None,
payload: iq::IqType::Result(None),
};
let elem2 = iq::serialise(&iq2);
assert_eq!(elem, elem2);
}
#[test]
fn test_disco() {
let elem: Element = "<iq xmlns='jabber:client' type='get'><query xmlns='http://jabber.org/protocol/disco#info'/></iq>".parse().unwrap();
let iq = iq::parse_iq(&elem).unwrap();
assert!(match iq.payload {
iq::IqType::Get(iq::IqPayloadType::Parsed(iq::IqPayload::Disco(disco::Disco { .. }))) => true,
_ => false,
});
}
}