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;
13use jingle::{Creator, ContentId};
14use date::DateTime;
15
16use minidom::{Element, IntoAttributeValue};
17
18use error::Error;
19use ns;
20
21generate_element_with_children!(
22 #[derive(PartialEq, Default)]
23 Range, "range", ns::JINGLE_FT,
24 attributes: [
25 offset: u64 = "offset" => default,
26 length: Option<u64> = "length" => optional
27 ],
28 children: [
29 hashes: Vec<Hash> = ("hash", ns::HASHES) => Hash
30 ]
31);
32
33impl Range {
34 pub fn new() -> Range {
35 Default::default()
36 }
37}
38
39type Lang = String;
40
41generate_id!(Desc);
42
43#[derive(Debug, Clone)]
44pub struct File {
45 pub date: Option<DateTime>,
46 pub media_type: Option<String>,
47 pub name: Option<String>,
48 pub descs: BTreeMap<Lang, Desc>,
49 pub size: Option<u64>,
50 pub range: Option<Range>,
51 pub hashes: Vec<Hash>,
52}
53
54impl File {
55 pub fn new() -> File {
56 File {
57 date: None,
58 media_type: None,
59 name: None,
60 descs: BTreeMap::new(),
61 size: None,
62 range: None,
63 hashes: Vec::new(),
64 }
65 }
66
67 pub fn with_date(mut self, date: DateTime) -> File {
68 self.date = Some(date);
69 self
70 }
71
72 pub fn with_date_str(mut self, date: &str) -> Result<File, Error> {
73 self.date = Some(DateTime::from_str(date)?);
74 Ok(self)
75 }
76
77 pub fn with_media_type(mut self, media_type: String) -> File {
78 self.media_type = Some(media_type);
79 self
80 }
81
82 pub fn with_name(mut self, name: String) -> File {
83 self.name = Some(name);
84 self
85 }
86
87 pub fn add_desc(mut self, lang: &str, desc: Desc) -> File {
88 self.descs.insert(Lang::from(lang), desc);
89 self
90 }
91
92 pub fn with_size(mut self, size: u64) -> File {
93 self.size = Some(size);
94 self
95 }
96
97 pub fn with_range(mut self, range: Range) -> File {
98 self.range = Some(range);
99 self
100 }
101
102 pub fn add_hash(mut self, hash: Hash) -> File {
103 self.hashes.push(hash);
104 self
105 }
106}
107
108impl TryFrom<Element> for File {
109 type Err = Error;
110
111 fn try_from(elem: Element) -> Result<File, Error> {
112 check_self!(elem, "file", ns::JINGLE_FT);
113 check_no_attributes!(elem, "file");
114
115 let mut file = File {
116 date: None,
117 media_type: None,
118 name: None,
119 descs: BTreeMap::new(),
120 size: None,
121 range: None,
122 hashes: vec!(),
123 };
124
125 for child in elem.children() {
126 if child.is("date", ns::JINGLE_FT) {
127 if file.date.is_some() {
128 return Err(Error::ParseError("File must not have more than one date."));
129 }
130 file.date = Some(child.text().parse()?);
131 } else if child.is("media-type", ns::JINGLE_FT) {
132 if file.media_type.is_some() {
133 return Err(Error::ParseError("File must not have more than one media-type."));
134 }
135 file.media_type = Some(child.text());
136 } else if child.is("name", ns::JINGLE_FT) {
137 if file.name.is_some() {
138 return Err(Error::ParseError("File must not have more than one name."));
139 }
140 file.name = Some(child.text());
141 } else if child.is("desc", ns::JINGLE_FT) {
142 let lang = get_attr!(child, "xml:lang", default);
143 let desc = Desc(child.text());
144 if file.descs.insert(lang, desc).is_some() {
145 return Err(Error::ParseError("Desc element present twice for the same xml:lang."));
146 }
147 } else if child.is("size", ns::JINGLE_FT) {
148 if file.size.is_some() {
149 return Err(Error::ParseError("File must not have more than one size."));
150 }
151 file.size = Some(child.text().parse()?);
152 } else if child.is("range", ns::JINGLE_FT) {
153 if file.range.is_some() {
154 return Err(Error::ParseError("File must not have more than one range."));
155 }
156 file.range = Some(Range::try_from(child.clone())?);
157 } else if child.is("hash", ns::HASHES) {
158 file.hashes.push(Hash::try_from(child.clone())?);
159 } else {
160 return Err(Error::ParseError("Unknown element in JingleFT file."));
161 }
162 }
163
164 Ok(file)
165 }
166}
167
168impl From<File> for Element {
169 fn from(file: File) -> Element {
170 let mut root = Element::builder("file")
171 .ns(ns::JINGLE_FT);
172 if let Some(date) = file.date {
173 root = root.append(Element::builder("date")
174 .ns(ns::JINGLE_FT)
175 .append(date)
176 .build());
177 }
178 if let Some(media_type) = file.media_type {
179 root = root.append(Element::builder("media-type")
180 .ns(ns::JINGLE_FT)
181 .append(media_type)
182 .build());
183 }
184 if let Some(name) = file.name {
185 root = root.append(Element::builder("name")
186 .ns(ns::JINGLE_FT)
187 .append(name)
188 .build());
189 }
190 for (lang, desc) in file.descs.into_iter() {
191 root = root.append(Element::builder("desc")
192 .ns(ns::JINGLE_FT)
193 .attr("xml:lang", lang)
194 .append(desc.0)
195 .build());
196 }
197 if let Some(size) = file.size {
198 root = root.append(Element::builder("size")
199 .ns(ns::JINGLE_FT)
200 .append(format!("{}", size))
201 .build());
202 }
203 if let Some(range) = file.range {
204 root = root.append(range);
205 }
206 for hash in file.hashes {
207 root = root.append(hash);
208 }
209 root.build()
210 }
211}
212#[derive(Debug, Clone)]
213pub struct Description {
214 pub file: File,
215}
216
217impl TryFrom<Element> for Description {
218 type Err = Error;
219
220 fn try_from(elem: Element) -> Result<Description, Error> {
221 check_self!(elem, "description", ns::JINGLE_FT, "JingleFT description");
222 check_no_attributes!(elem, "JingleFT description");
223 let mut file = None;
224 for child in elem.children() {
225 if file.is_some() {
226 return Err(Error::ParseError("JingleFT description element must have exactly one child."));
227 }
228 file = Some(File::try_from(child.clone())?);
229 }
230 if file.is_none() {
231 return Err(Error::ParseError("JingleFT description element must have exactly one child."));
232 }
233 Ok(Description {
234 file: file.unwrap(),
235 })
236 }
237}
238
239impl From<Description> for Element {
240 fn from(description: Description) -> Element {
241 Element::builder("description")
242 .ns(ns::JINGLE_FT)
243 .append(description.file)
244 .build()
245 }
246}
247
248#[derive(Debug, Clone)]
249pub struct Checksum {
250 pub name: ContentId,
251 pub creator: Creator,
252 pub file: File,
253}
254
255impl TryFrom<Element> for Checksum {
256 type Err = Error;
257
258 fn try_from(elem: Element) -> Result<Checksum, Error> {
259 check_self!(elem, "checksum", ns::JINGLE_FT);
260 check_no_unknown_attributes!(elem, "checksum", ["name", "creator"]);
261 let mut file = None;
262 for child in elem.children() {
263 if file.is_some() {
264 return Err(Error::ParseError("JingleFT checksum element must have exactly one child."));
265 }
266 file = Some(File::try_from(child.clone())?);
267 }
268 if file.is_none() {
269 return Err(Error::ParseError("JingleFT checksum element must have exactly one child."));
270 }
271 Ok(Checksum {
272 name: get_attr!(elem, "name", required),
273 creator: get_attr!(elem, "creator", required),
274 file: file.unwrap(),
275 })
276 }
277}
278
279impl From<Checksum> for Element {
280 fn from(checksum: Checksum) -> Element {
281 Element::builder("checksum")
282 .ns(ns::JINGLE_FT)
283 .attr("name", checksum.name)
284 .attr("creator", checksum.creator)
285 .append(checksum.file)
286 .build()
287 }
288}
289
290generate_element_with_only_attributes!(Received, "received", ns::JINGLE_FT, [
291 name: ContentId = "name" => required,
292 creator: Creator = "creator" => required,
293]);
294
295#[cfg(test)]
296mod tests {
297 use super::*;
298 use hashes::Algo;
299 use base64;
300
301 #[test]
302 fn test_description() {
303 let elem: Element = r#"
304<description xmlns='urn:xmpp:jingle:apps:file-transfer:5'>
305 <file>
306 <media-type>text/plain</media-type>
307 <name>test.txt</name>
308 <date>2015-07-26T21:46:00+01:00</date>
309 <size>6144</size>
310 <hash xmlns='urn:xmpp:hashes:2'
311 algo='sha-1'>w0mcJylzCn+AfvuGdqkty2+KP48=</hash>
312 </file>
313</description>
314"#.parse().unwrap();
315 let desc = Description::try_from(elem).unwrap();
316 assert_eq!(desc.file.media_type, Some(String::from("text/plain")));
317 assert_eq!(desc.file.name, Some(String::from("test.txt")));
318 assert_eq!(desc.file.descs, BTreeMap::new());
319 assert_eq!(desc.file.date, DateTime::from_str("2015-07-26T21:46:00+01:00").ok());
320 assert_eq!(desc.file.size, Some(6144u64));
321 assert_eq!(desc.file.range, None);
322 assert_eq!(desc.file.hashes[0].algo, Algo::Sha_1);
323 assert_eq!(desc.file.hashes[0].hash, base64::decode("w0mcJylzCn+AfvuGdqkty2+KP48=").unwrap());
324 }
325
326 #[test]
327 fn test_request() {
328 let elem: Element = r#"
329<description xmlns='urn:xmpp:jingle:apps:file-transfer:5'>
330 <file>
331 <hash xmlns='urn:xmpp:hashes:2'
332 algo='sha-1'>w0mcJylzCn+AfvuGdqkty2+KP48=</hash>
333 </file>
334</description>
335"#.parse().unwrap();
336 let desc = Description::try_from(elem).unwrap();
337 assert_eq!(desc.file.media_type, None);
338 assert_eq!(desc.file.name, None);
339 assert_eq!(desc.file.descs, BTreeMap::new());
340 assert_eq!(desc.file.date, None);
341 assert_eq!(desc.file.size, None);
342 assert_eq!(desc.file.range, None);
343 assert_eq!(desc.file.hashes[0].algo, Algo::Sha_1);
344 assert_eq!(desc.file.hashes[0].hash, base64::decode("w0mcJylzCn+AfvuGdqkty2+KP48=").unwrap());
345 }
346
347 #[test]
348 fn test_descs() {
349 let elem: Element = r#"
350<description xmlns='urn:xmpp:jingle:apps:file-transfer:5'>
351 <file>
352 <media-type>text/plain</media-type>
353 <desc xml:lang='fr'>Fichier secret !</desc>
354 <desc xml:lang='en'>Secret file!</desc>
355 <hash xmlns='urn:xmpp:hashes:2'
356 algo='sha-1'>w0mcJylzCn+AfvuGdqkty2+KP48=</hash>
357 </file>
358</description>
359"#.parse().unwrap();
360 let desc = Description::try_from(elem).unwrap();
361 assert_eq!(desc.file.descs.keys().cloned().collect::<Vec<_>>(), ["en", "fr"]);
362 assert_eq!(desc.file.descs["en"], Desc(String::from("Secret file!")));
363 assert_eq!(desc.file.descs["fr"], Desc(String::from("Fichier secret !")));
364
365 let elem: Element = r#"
366<description xmlns='urn:xmpp:jingle:apps:file-transfer:5'>
367 <file>
368 <media-type>text/plain</media-type>
369 <desc xml:lang='fr'>Fichier secret !</desc>
370 <desc xml:lang='fr'>Secret file!</desc>
371 <hash xmlns='urn:xmpp:hashes:2'
372 algo='sha-1'>w0mcJylzCn+AfvuGdqkty2+KP48=</hash>
373 </file>
374</description>
375"#.parse().unwrap();
376 let error = Description::try_from(elem).unwrap_err();
377 let message = match error {
378 Error::ParseError(string) => string,
379 _ => panic!(),
380 };
381 assert_eq!(message, "Desc element present twice for the same xml:lang.");
382 }
383
384 #[test]
385 fn test_received() {
386 let elem: Element = "<received xmlns='urn:xmpp:jingle:apps:file-transfer:5' name='coucou' creator='initiator'/>".parse().unwrap();
387 let received = Received::try_from(elem).unwrap();
388 assert_eq!(received.name, ContentId(String::from("coucou")));
389 assert_eq!(received.creator, Creator::Initiator);
390 let elem2 = Element::from(received.clone());
391 let received2 = Received::try_from(elem2).unwrap();
392 assert_eq!(received2.name, ContentId(String::from("coucou")));
393 assert_eq!(received2.creator, Creator::Initiator);
394
395 let elem: Element = "<received xmlns='urn:xmpp:jingle:apps:file-transfer:5' name='coucou' creator='initiator'><coucou/></received>".parse().unwrap();
396 let error = Received::try_from(elem).unwrap_err();
397 let message = match error {
398 Error::ParseError(string) => string,
399 _ => panic!(),
400 };
401 assert_eq!(message, "Unknown child in received element.");
402
403 let elem: Element = "<received xmlns='urn:xmpp:jingle:apps:file-transfer:5' name='coucou' creator='initiator' coucou=''/>".parse().unwrap();
404 let error = Received::try_from(elem).unwrap_err();
405 let message = match error {
406 Error::ParseError(string) => string,
407 _ => panic!(),
408 };
409 assert_eq!(message, "Unknown attribute in received element.");
410
411 let elem: Element = "<received xmlns='urn:xmpp:jingle:apps:file-transfer:5' creator='initiator'/>".parse().unwrap();
412 let error = Received::try_from(elem).unwrap_err();
413 let message = match error {
414 Error::ParseError(string) => string,
415 _ => panic!(),
416 };
417 assert_eq!(message, "Required attribute 'name' missing.");
418
419 let elem: Element = "<received xmlns='urn:xmpp:jingle:apps:file-transfer:5' name='coucou' creator='coucou'/>".parse().unwrap();
420 let error = Received::try_from(elem).unwrap_err();
421 let message = match error {
422 Error::ParseError(string) => string,
423 _ => panic!(),
424 };
425 assert_eq!(message, "Unknown value for 'creator' attribute.");
426 }
427
428 #[test]
429 fn test_checksum() {
430 let elem: Element = "<checksum xmlns='urn:xmpp:jingle:apps:file-transfer:5' name='coucou' creator='initiator'><file><hash xmlns='urn:xmpp:hashes:2' algo='sha-1'>w0mcJylzCn+AfvuGdqkty2+KP48=</hash></file></checksum>".parse().unwrap();
431 let hash = vec!(195, 73, 156, 39, 41, 115, 10, 127, 128, 126, 251, 134, 118, 169, 45, 203, 111, 138, 63, 143);
432 let checksum = Checksum::try_from(elem).unwrap();
433 assert_eq!(checksum.name, ContentId(String::from("coucou")));
434 assert_eq!(checksum.creator, Creator::Initiator);
435 assert_eq!(checksum.file.hashes, vec!(Hash { algo: Algo::Sha_1, hash: hash.clone() }));
436 let elem2 = Element::from(checksum);
437 let checksum2 = Checksum::try_from(elem2).unwrap();
438 assert_eq!(checksum2.name, ContentId(String::from("coucou")));
439 assert_eq!(checksum2.creator, Creator::Initiator);
440 assert_eq!(checksum2.file.hashes, vec!(Hash { algo: Algo::Sha_1, hash: hash.clone() }));
441
442 let elem: Element = "<checksum xmlns='urn:xmpp:jingle:apps:file-transfer:5' name='coucou' creator='initiator'><coucou/></checksum>".parse().unwrap();
443 let error = Checksum::try_from(elem).unwrap_err();
444 let message = match error {
445 Error::ParseError(string) => string,
446 _ => panic!(),
447 };
448 assert_eq!(message, "This is not a file element.");
449
450 let elem: Element = "<checksum xmlns='urn:xmpp:jingle:apps:file-transfer:5' name='coucou' creator='initiator' coucou=''><file><hash xmlns='urn:xmpp:hashes:2' algo='sha-1'>w0mcJylzCn+AfvuGdqkty2+KP48=</hash></file></checksum>".parse().unwrap();
451 let error = Checksum::try_from(elem).unwrap_err();
452 let message = match error {
453 Error::ParseError(string) => string,
454 _ => panic!(),
455 };
456 assert_eq!(message, "Unknown attribute in checksum element.");
457
458 let elem: Element = "<checksum xmlns='urn:xmpp:jingle:apps:file-transfer:5' creator='initiator'><file><hash xmlns='urn:xmpp:hashes:2' algo='sha-1'>w0mcJylzCn+AfvuGdqkty2+KP48=</hash></file></checksum>".parse().unwrap();
459 let error = Checksum::try_from(elem).unwrap_err();
460 let message = match error {
461 Error::ParseError(string) => string,
462 _ => panic!(),
463 };
464 assert_eq!(message, "Required attribute 'name' missing.");
465
466 let elem: Element = "<checksum xmlns='urn:xmpp:jingle:apps:file-transfer:5' name='coucou' creator='coucou'><file><hash xmlns='urn:xmpp:hashes:2' algo='sha-1'>w0mcJylzCn+AfvuGdqkty2+KP48=</hash></file></checksum>".parse().unwrap();
467 let error = Checksum::try_from(elem).unwrap_err();
468 let message = match error {
469 Error::ParseError(string) => string,
470 _ => panic!(),
471 };
472 assert_eq!(message, "Unknown value for 'creator' attribute.");
473 }
474
475 #[test]
476 fn test_range() {
477 let elem: Element = "<range xmlns='urn:xmpp:jingle:apps:file-transfer:5'/>".parse().unwrap();
478 let range = Range::try_from(elem).unwrap();
479 assert_eq!(range.offset, 0);
480 assert_eq!(range.length, None);
481 assert_eq!(range.hashes, vec!());
482
483 let elem: Element = "<range xmlns='urn:xmpp:jingle:apps:file-transfer:5' offset='2048' length='1024'><hash xmlns='urn:xmpp:hashes:2' algo='sha-1'>kHp5RSzW/h7Gm1etSf90Mr5PC/k=</hash></range>".parse().unwrap();
484 let hashes = vec!(Hash { algo: Algo::Sha_1, hash: vec!(144, 122, 121, 69, 44, 214, 254, 30, 198, 155, 87, 173, 73, 255, 116, 50, 190, 79, 11, 249) });
485 let range = Range::try_from(elem).unwrap();
486 assert_eq!(range.offset, 2048);
487 assert_eq!(range.length, Some(1024));
488 assert_eq!(range.hashes, hashes);
489 let elem2 = Element::from(range);
490 let range2 = Range::try_from(elem2).unwrap();
491 assert_eq!(range2.offset, 2048);
492 assert_eq!(range2.length, Some(1024));
493 assert_eq!(range2.hashes, hashes);
494
495 let elem: Element = "<range xmlns='urn:xmpp:jingle:apps:file-transfer:5' coucou=''/>".parse().unwrap();
496 let error = Range::try_from(elem).unwrap_err();
497 let message = match error {
498 Error::ParseError(string) => string,
499 _ => panic!(),
500 };
501 assert_eq!(message, "Unknown attribute in range element.");
502 }
503}