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;
8
9use std::collections::BTreeMap;
10use std::str::FromStr;
11
12use hashes::Hash;
13
14use minidom::{Element, IntoElements, IntoAttributeValue, ElementEmitter};
15use chrono::{DateTime, FixedOffset};
16
17use error::Error;
18use ns;
19
20#[derive(Debug, Clone, PartialEq)]
21pub struct Range {
22 pub offset: u64,
23 pub length: Option<u64>,
24 pub hashes: Vec<Hash>,
25}
26
27impl IntoElements for Range {
28 fn into_elements(self, emitter: &mut ElementEmitter) {
29 let mut elem = Element::builder("range")
30 .ns(ns::JINGLE_FT)
31 .attr("offset", if self.offset == 0 { None } else { Some(self.offset) })
32 .attr("length", self.length)
33 .build();
34 for hash in self.hashes {
35 elem.append_child(hash.into());
36 }
37 emitter.append_child(elem);
38 }
39}
40
41type Lang = String;
42
43generate_id!(Desc);
44
45#[derive(Debug, Clone)]
46pub struct File {
47 pub date: Option<DateTime<FixedOffset>>,
48 pub media_type: Option<String>,
49 pub name: Option<String>,
50 pub descs: BTreeMap<Lang, Desc>,
51 pub size: Option<u64>,
52 pub range: Option<Range>,
53 pub hashes: Vec<Hash>,
54}
55
56#[derive(Debug, Clone)]
57pub struct Description {
58 pub file: File,
59}
60
61#[derive(Debug, Clone)]
62pub enum Creator {
63 Initiator,
64 Responder,
65}
66
67#[derive(Debug, Clone)]
68pub struct Checksum {
69 pub name: String,
70 pub creator: Creator,
71 pub file: File,
72}
73
74#[derive(Debug, Clone)]
75pub struct Received {
76 pub name: String,
77 pub creator: Creator,
78}
79
80impl IntoElements for Received {
81 fn into_elements(self, emitter: &mut ElementEmitter) {
82 let elem = Element::builder("received")
83 .ns(ns::JINGLE_FT)
84 .attr("name", self.name)
85 .attr("creator", match self.creator {
86 Creator::Initiator => "initiator",
87 Creator::Responder => "responder",
88 })
89 .build();
90 emitter.append_child(elem);
91 }
92}
93
94impl TryFrom<Element> for Description {
95 type Err = Error;
96
97 fn try_from(elem: Element) -> Result<Description, Error> {
98 if !elem.is("description", ns::JINGLE_FT) {
99 return Err(Error::ParseError("This is not a JingleFT description element."));
100 }
101 if elem.children().count() != 1 {
102 return Err(Error::ParseError("JingleFT description element must have exactly one child."));
103 }
104
105 let mut date = None;
106 let mut media_type = None;
107 let mut name = None;
108 let mut descs = BTreeMap::new();
109 let mut size = None;
110 let mut range = None;
111 let mut hashes = vec!();
112 for description_payload in elem.children() {
113 if !description_payload.is("file", ns::JINGLE_FT) {
114 return Err(Error::ParseError("Unknown element in JingleFT description."));
115 }
116 for file_payload in description_payload.children() {
117 if file_payload.is("date", ns::JINGLE_FT) {
118 if date.is_some() {
119 return Err(Error::ParseError("File must not have more than one date."));
120 }
121 date = Some(file_payload.text().parse()?);
122 } else if file_payload.is("media-type", ns::JINGLE_FT) {
123 if media_type.is_some() {
124 return Err(Error::ParseError("File must not have more than one media-type."));
125 }
126 media_type = Some(file_payload.text());
127 } else if file_payload.is("name", ns::JINGLE_FT) {
128 if name.is_some() {
129 return Err(Error::ParseError("File must not have more than one name."));
130 }
131 name = Some(file_payload.text());
132 } else if file_payload.is("desc", ns::JINGLE_FT) {
133 let lang = get_attr!(file_payload, "xml:lang", default);
134 let desc = Desc(file_payload.text());
135 if descs.insert(lang, desc).is_some() {
136 return Err(Error::ParseError("Desc element present twice for the same xml:lang."));
137 }
138 } else if file_payload.is("size", ns::JINGLE_FT) {
139 if size.is_some() {
140 return Err(Error::ParseError("File must not have more than one size."));
141 }
142 size = Some(file_payload.text().parse()?);
143 } else if file_payload.is("range", ns::JINGLE_FT) {
144 if range.is_some() {
145 return Err(Error::ParseError("File must not have more than one range."));
146 }
147 let offset = get_attr!(file_payload, "offset", default);
148 let length = get_attr!(file_payload, "length", optional);
149 let mut range_hashes = vec!();
150 for hash_element in file_payload.children() {
151 if !hash_element.is("hash", ns::HASHES) {
152 return Err(Error::ParseError("Unknown element in JingleFT range."));
153 }
154 range_hashes.push(Hash::try_from(hash_element.clone())?);
155 }
156 range = Some(Range {
157 offset: offset,
158 length: length,
159 hashes: range_hashes,
160 });
161 } else if file_payload.is("hash", ns::HASHES) {
162 hashes.push(Hash::try_from(file_payload.clone())?);
163 } else {
164 return Err(Error::ParseError("Unknown element in JingleFT file."));
165 }
166 }
167 }
168
169 Ok(Description {
170 file: File {
171 date: date,
172 media_type: media_type,
173 name: name,
174 descs: descs,
175 size: size,
176 range: range,
177 hashes: hashes,
178 },
179 })
180 }
181}
182
183impl From<File> for Element {
184 fn from(file: File) -> Element {
185 let mut root = Element::builder("file")
186 .ns(ns::JINGLE_FT)
187 .build();
188 if let Some(date) = file.date {
189 root.append_child(Element::builder("date")
190 .ns(ns::JINGLE_FT)
191 .append(date.to_rfc3339())
192 .build());
193 }
194 if let Some(media_type) = file.media_type {
195 root.append_child(Element::builder("media-type")
196 .ns(ns::JINGLE_FT)
197 .append(media_type)
198 .build());
199 }
200 if let Some(name) = file.name {
201 root.append_child(Element::builder("name")
202 .ns(ns::JINGLE_FT)
203 .append(name)
204 .build());
205 }
206 for (lang, desc) in file.descs.into_iter() {
207 root.append_child(Element::builder("desc")
208 .ns(ns::JINGLE_FT)
209 .attr("xml:lang", lang)
210 .append(desc.0)
211 .build());
212 }
213 if let Some(size) = file.size {
214 root.append_child(Element::builder("size")
215 .ns(ns::JINGLE_FT)
216 .append(format!("{}", size))
217 .build());
218 }
219 if let Some(range) = file.range {
220 root.append_child(Element::builder("range")
221 .ns(ns::JINGLE_FT)
222 .append(range)
223 .build());
224 }
225 for hash in file.hashes {
226 root.append_child(hash.into());
227 }
228 root
229 }
230}
231
232impl From<Description> for Element {
233 fn from(description: Description) -> Element {
234 let file: Element = description.file.into();
235 Element::builder("description")
236 .ns(ns::JINGLE_FT)
237 .append(file)
238 .build()
239 }
240}
241
242#[cfg(test)]
243mod tests {
244 use super::*;
245 use hashes::Algo;
246 use base64;
247
248 #[test]
249 fn test_description() {
250 let elem: Element = r#"
251<description xmlns='urn:xmpp:jingle:apps:file-transfer:5'>
252 <file>
253 <media-type>text/plain</media-type>
254 <name>test.txt</name>
255 <date>2015-07-26T21:46:00+01:00</date>
256 <size>6144</size>
257 <hash xmlns='urn:xmpp:hashes:2'
258 algo='sha-1'>w0mcJylzCn+AfvuGdqkty2+KP48=</hash>
259 </file>
260</description>
261"#.parse().unwrap();
262 let desc = Description::try_from(elem).unwrap();
263 assert_eq!(desc.file.media_type, Some(String::from("text/plain")));
264 assert_eq!(desc.file.name, Some(String::from("test.txt")));
265 assert_eq!(desc.file.descs, BTreeMap::new());
266 assert_eq!(desc.file.date, Some(DateTime::parse_from_rfc3339("2015-07-26T21:46:00+01:00").unwrap()));
267 assert_eq!(desc.file.size, Some(6144u64));
268 assert_eq!(desc.file.range, None);
269 assert_eq!(desc.file.hashes[0].algo, Algo::Sha_1);
270 assert_eq!(desc.file.hashes[0].hash, base64::decode("w0mcJylzCn+AfvuGdqkty2+KP48=").unwrap());
271 }
272
273 #[test]
274 fn test_request() {
275 let elem: Element = r#"
276<description xmlns='urn:xmpp:jingle:apps:file-transfer:5'>
277 <file>
278 <hash xmlns='urn:xmpp:hashes:2'
279 algo='sha-1'>w0mcJylzCn+AfvuGdqkty2+KP48=</hash>
280 </file>
281</description>
282"#.parse().unwrap();
283 let desc = Description::try_from(elem).unwrap();
284 assert_eq!(desc.file.media_type, None);
285 assert_eq!(desc.file.name, None);
286 assert_eq!(desc.file.descs, BTreeMap::new());
287 assert_eq!(desc.file.date, None);
288 assert_eq!(desc.file.size, None);
289 assert_eq!(desc.file.range, None);
290 assert_eq!(desc.file.hashes[0].algo, Algo::Sha_1);
291 assert_eq!(desc.file.hashes[0].hash, base64::decode("w0mcJylzCn+AfvuGdqkty2+KP48=").unwrap());
292 }
293
294 #[test]
295 fn test_descs() {
296 let elem: Element = r#"
297<description xmlns='urn:xmpp:jingle:apps:file-transfer:5'>
298 <file>
299 <media-type>text/plain</media-type>
300 <desc xml:lang='fr'>Fichier secret !</desc>
301 <desc xml:lang='en'>Secret file!</desc>
302 <hash xmlns='urn:xmpp:hashes:2'
303 algo='sha-1'>w0mcJylzCn+AfvuGdqkty2+KP48=</hash>
304 </file>
305</description>
306"#.parse().unwrap();
307 let desc = Description::try_from(elem).unwrap();
308 assert_eq!(desc.file.descs.keys().cloned().collect::<Vec<_>>(), ["en", "fr"]);
309 assert_eq!(desc.file.descs["en"], Desc(String::from("Secret file!")));
310 assert_eq!(desc.file.descs["fr"], Desc(String::from("Fichier secret !")));
311
312 let elem: Element = r#"
313<description xmlns='urn:xmpp:jingle:apps:file-transfer:5'>
314 <file>
315 <media-type>text/plain</media-type>
316 <desc xml:lang='fr'>Fichier secret !</desc>
317 <desc xml:lang='fr'>Secret file!</desc>
318 <hash xmlns='urn:xmpp:hashes:2'
319 algo='sha-1'>w0mcJylzCn+AfvuGdqkty2+KP48=</hash>
320 </file>
321</description>
322"#.parse().unwrap();
323 let error = Description::try_from(elem).unwrap_err();
324 let message = match error {
325 Error::ParseError(string) => string,
326 _ => panic!(),
327 };
328 assert_eq!(message, "Desc element present twice for the same xml:lang.");
329 }
330}