1// Copyright (c) 2017 Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
2//
3// This Source Code Form is subject to the terms of the Mozilla Public
4// License, v. 2.0. If a copy of the MPL was not distributed with this
5// file, You can obtain one at http://mozilla.org/MPL/2.0/.
6
7use try_from::TryFrom;
8use std::str::FromStr;
9use std::collections::BTreeMap;
10
11use minidom::{Element, IntoAttributeValue};
12
13use jid::Jid;
14
15use error::Error;
16
17use ns;
18
19use stanza_error::StanzaError;
20use chatstates::ChatState;
21use receipts::{Request as ReceiptRequest, Received as ReceiptReceived};
22use delay::Delay;
23use attention::Attention;
24use message_correct::Replace;
25use eme::ExplicitMessageEncryption;
26use stanza_id::{StanzaId, OriginId};
27use mam::Result_ as MamResult;
28
29/// Lists every known payload of a `<message/>`.
30#[derive(Debug, Clone)]
31pub enum MessagePayload {
32 StanzaError(StanzaError),
33 ChatState(ChatState),
34 ReceiptRequest(ReceiptRequest),
35 ReceiptReceived(ReceiptReceived),
36 Delay(Delay),
37 Attention(Attention),
38 MessageCorrect(Replace),
39 ExplicitMessageEncryption(ExplicitMessageEncryption),
40 StanzaId(StanzaId),
41 OriginId(OriginId),
42 MamResult(MamResult),
43
44 Unknown(Element),
45}
46
47impl TryFrom<Element> for MessagePayload {
48 type Err = Error;
49
50 fn try_from(elem: Element) -> Result<MessagePayload, Error> {
51 Ok(match (elem.name().as_ref(), elem.ns().unwrap().as_ref()) {
52 ("error", ns::JABBER_CLIENT) => MessagePayload::StanzaError(StanzaError::try_from(elem)?),
53
54 // XEP-0085
55 ("active", ns::CHATSTATES)
56 | ("inactive", ns::CHATSTATES)
57 | ("composing", ns::CHATSTATES)
58 | ("paused", ns::CHATSTATES)
59 | ("gone", ns::CHATSTATES) => MessagePayload::ChatState(ChatState::try_from(elem)?),
60
61 // XEP-0184
62 ("request", ns::RECEIPTS) => MessagePayload::ReceiptRequest(ReceiptRequest::try_from(elem)?),
63 ("received", ns::RECEIPTS) => MessagePayload::ReceiptReceived(ReceiptReceived::try_from(elem)?),
64
65 // XEP-0203
66 ("delay", ns::DELAY) => MessagePayload::Delay(Delay::try_from(elem)?),
67
68 // XEP-0224
69 ("attention", ns::ATTENTION) => MessagePayload::Attention(Attention::try_from(elem)?),
70
71 // XEP-0308
72 ("replace", ns::MESSAGE_CORRECT) => MessagePayload::MessageCorrect(Replace::try_from(elem)?),
73
74 // XEP-0313
75 ("result", ns::MAM) => MessagePayload::MamResult(MamResult::try_from(elem)?),
76
77 // XEP-0359
78 ("stanza-id", ns::SID) => MessagePayload::StanzaId(StanzaId::try_from(elem)?),
79 ("origin-id", ns::SID) => MessagePayload::OriginId(OriginId::try_from(elem)?),
80
81 // XEP-0380
82 ("encryption", ns::EME) => MessagePayload::ExplicitMessageEncryption(ExplicitMessageEncryption::try_from(elem)?),
83
84 _ => MessagePayload::Unknown(elem),
85 })
86 }
87}
88
89impl From<MessagePayload> for Element {
90 fn from(payload: MessagePayload) -> Element {
91 match payload {
92 MessagePayload::StanzaError(stanza_error) => stanza_error.into(),
93 MessagePayload::Attention(attention) => attention.into(),
94 MessagePayload::ChatState(chatstate) => chatstate.into(),
95 MessagePayload::ReceiptRequest(request) => request.into(),
96 MessagePayload::ReceiptReceived(received) => received.into(),
97 MessagePayload::Delay(delay) => delay.into(),
98 MessagePayload::MessageCorrect(replace) => replace.into(),
99 MessagePayload::ExplicitMessageEncryption(eme) => eme.into(),
100 MessagePayload::StanzaId(stanza_id) => stanza_id.into(),
101 MessagePayload::OriginId(origin_id) => origin_id.into(),
102 MessagePayload::MamResult(result) => result.into(),
103
104 MessagePayload::Unknown(elem) => elem,
105 }
106 }
107}
108
109generate_attribute!(MessageType, "type", {
110 Chat => "chat",
111 Error => "error",
112 Groupchat => "groupchat",
113 Headline => "headline",
114 Normal => "normal",
115}, Default = Normal);
116
117type Lang = String;
118type Body = String;
119type Subject = String;
120type Thread = String;
121
122/// The main structure representing the `<message/>` stanza.
123#[derive(Debug, Clone)]
124pub struct Message {
125 pub from: Option<Jid>,
126 pub to: Option<Jid>,
127 pub id: Option<String>,
128 pub type_: MessageType,
129 pub bodies: BTreeMap<Lang, Body>,
130 pub subjects: BTreeMap<Lang, Subject>,
131 pub thread: Option<Thread>,
132 pub payloads: Vec<Element>,
133}
134
135impl Message {
136 pub fn new(to: Option<Jid>) -> Message {
137 Message {
138 from: None,
139 to: to,
140 id: None,
141 type_: MessageType::Chat,
142 bodies: BTreeMap::new(),
143 subjects: BTreeMap::new(),
144 thread: None,
145 payloads: vec!(),
146 }
147 }
148}
149
150impl TryFrom<Element> for Message {
151 type Err = Error;
152
153 fn try_from(root: Element) -> Result<Message, Error> {
154 if !root.is("message", ns::JABBER_CLIENT) {
155 return Err(Error::ParseError("This is not a message element."));
156 }
157 let from = get_attr!(root, "from", optional);
158 let to = get_attr!(root, "to", optional);
159 let id = get_attr!(root, "id", optional);
160 let type_ = get_attr!(root, "type", default);
161 let mut bodies = BTreeMap::new();
162 let mut subjects = BTreeMap::new();
163 let mut thread = None;
164 let mut payloads = vec!();
165 for elem in root.children() {
166 if elem.is("body", ns::JABBER_CLIENT) {
167 for _ in elem.children() {
168 return Err(Error::ParseError("Unknown child in body element."));
169 }
170 let lang = get_attr!(root, "xml:lang", default);
171 if bodies.insert(lang, elem.text()).is_some() {
172 return Err(Error::ParseError("Body element present twice for the same xml:lang."));
173 }
174 } else if elem.is("subject", ns::JABBER_CLIENT) {
175 for _ in elem.children() {
176 return Err(Error::ParseError("Unknown child in subject element."));
177 }
178 let lang = get_attr!(root, "xml:lang", default);
179 if subjects.insert(lang, elem.text()).is_some() {
180 return Err(Error::ParseError("Subject element present twice for the same xml:lang."));
181 }
182 } else if elem.is("thread", ns::JABBER_CLIENT) {
183 if thread.is_some() {
184 return Err(Error::ParseError("Thread element present twice."));
185 }
186 for _ in elem.children() {
187 return Err(Error::ParseError("Unknown child in thread element."));
188 }
189 thread = Some(elem.text());
190 } else {
191 payloads.push(elem.clone())
192 }
193 }
194 Ok(Message {
195 from: from,
196 to: to,
197 id: id,
198 type_: type_,
199 bodies: bodies,
200 subjects: subjects,
201 thread: thread,
202 payloads: payloads,
203 })
204 }
205}
206
207impl From<Message> for Element {
208 fn from(message: Message) -> Element {
209 Element::builder("message")
210 .ns(ns::JABBER_CLIENT)
211 .attr("from", message.from.map(String::from))
212 .attr("to", message.to.map(String::from))
213 .attr("id", message.id)
214 .attr("type", message.type_)
215 .append(message.subjects.into_iter()
216 .map(|(lang, subject)| {
217 Element::builder("subject")
218 .ns(ns::JABBER_CLIENT)
219 .attr("xml:lang", match lang.as_ref() {
220 "" => None,
221 lang => Some(lang),
222 })
223 .append(subject)
224 .build() })
225 .collect::<Vec<_>>())
226 .append(message.bodies.into_iter()
227 .map(|(lang, body)| {
228 Element::builder("body")
229 .ns(ns::JABBER_CLIENT)
230 .attr("xml:lang", match lang.as_ref() {
231 "" => None,
232 lang => Some(lang),
233 })
234 .append(body)
235 .build() })
236 .collect::<Vec<_>>())
237 .append(message.payloads)
238 .build()
239 }
240}
241
242#[cfg(test)]
243mod tests {
244 use super::*;
245
246 #[test]
247 fn test_simple() {
248 let elem: Element = "<message xmlns='jabber:client'/>".parse().unwrap();
249 let message = Message::try_from(elem).unwrap();
250 assert_eq!(message.from, None);
251 assert_eq!(message.to, None);
252 assert_eq!(message.id, None);
253 assert_eq!(message.type_, MessageType::Normal);
254 assert!(message.payloads.is_empty());
255 }
256
257 #[test]
258 fn test_serialise() {
259 let elem: Element = "<message xmlns='jabber:client'/>".parse().unwrap();
260 let mut message = Message::new(None);
261 message.type_ = MessageType::Normal;
262 let elem2 = message.into();
263 assert_eq!(elem, elem2);
264 }
265
266 #[test]
267 fn test_body() {
268 let elem: Element = "<message xmlns='jabber:client' to='coucou@example.org' type='chat'><body>Hello world!</body></message>".parse().unwrap();
269 let elem1 = elem.clone();
270 let message = Message::try_from(elem).unwrap();
271 assert_eq!(message.bodies[""], "Hello world!");
272
273 let elem2 = message.into();
274 assert_eq!(elem1, elem2);
275 }
276
277 #[test]
278 fn test_serialise_body() {
279 let elem: Element = "<message xmlns='jabber:client' to='coucou@example.org' type='chat'><body>Hello world!</body></message>".parse().unwrap();
280 let mut message = Message::new(Some(Jid::from_str("coucou@example.org").unwrap()));
281 message.bodies.insert(String::from(""), String::from("Hello world!"));
282 let elem2 = message.into();
283 assert_eq!(elem, elem2);
284 }
285
286 #[test]
287 fn test_subject() {
288 let elem: Element = "<message xmlns='jabber:client' to='coucou@example.org' type='chat'><subject>Hello world!</subject></message>".parse().unwrap();
289 let elem1 = elem.clone();
290 let message = Message::try_from(elem).unwrap();
291 assert_eq!(message.subjects[""], "Hello world!");
292
293 let elem2 = message.into();
294 assert_eq!(elem1, elem2);
295 }
296
297 #[test]
298 fn test_attention() {
299 let elem: Element = "<message xmlns='jabber:client' to='coucou@example.org' type='chat'><attention xmlns='urn:xmpp:attention:0'/></message>".parse().unwrap();
300 let elem1 = elem.clone();
301 let message = Message::try_from(elem).unwrap();
302 let elem2 = message.into();
303 assert_eq!(elem1, elem2);
304 }
305}