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 hashes;
8use hashes::{Hash, parse_hash};
9
10use minidom::{Element, IntoElements};
11use minidom::convert::ElementEmitter;
12
13use error::Error;
14use ns;
15
16#[derive(Debug, Clone, PartialEq)]
17pub struct Range {
18 pub offset: u64,
19 pub length: Option<u64>,
20 pub hashes: Vec<Hash>,
21}
22
23impl IntoElements for Range {
24 fn into_elements(self, emitter: &mut ElementEmitter) {
25 let mut elem = Element::builder("range")
26 .ns(ns::JINGLE_FT)
27 .attr("offset", format!("{}", self.offset))
28 .attr("length", match self.length {
29 Some(length) => Some(format!("{}", length)),
30 None => None
31 })
32 .build();
33 for hash in self.hashes {
34 elem.append_child(hashes::serialise(&hash));
35 }
36 emitter.append_child(elem);
37 }
38}
39
40#[derive(Debug, Clone)]
41pub struct File {
42 pub date: Option<String>,
43 pub media_type: Option<String>,
44 pub name: Option<String>,
45 pub desc: Option<String>,
46 pub size: Option<u64>,
47 pub range: Option<Range>,
48 pub hashes: Vec<Hash>,
49}
50
51#[derive(Debug, Clone)]
52pub struct Description {
53 pub file: File,
54}
55
56#[derive(Debug, Clone)]
57pub enum Creator {
58 Initiator,
59 Responder,
60}
61
62#[derive(Debug, Clone)]
63pub struct Checksum {
64 pub name: String,
65 pub creator: Creator,
66 pub file: File,
67}
68
69#[derive(Debug, Clone)]
70pub struct Received {
71 pub name: String,
72 pub creator: Creator,
73}
74
75impl IntoElements for Received {
76 fn into_elements(self, emitter: &mut ElementEmitter) {
77 let elem = Element::builder("received")
78 .ns(ns::JINGLE_FT)
79 .attr("name", self.name)
80 .attr("creator", match self.creator {
81 Creator::Initiator => "initiator",
82 Creator::Responder => "responder",
83 })
84 .build();
85 emitter.append_child(elem);
86 }
87}
88
89pub fn parse_jingle_ft(root: &Element) -> Result<Description, Error> {
90 if !root.is("description", ns::JINGLE_FT) {
91 return Err(Error::ParseError("This is not a JingleFT description element."));
92 }
93 if root.children().collect::<Vec<_>>().len() != 1 {
94 return Err(Error::ParseError("JingleFT description element must have exactly one child."));
95 }
96
97 let mut date = None;
98 let mut media_type = None;
99 let mut name = None;
100 let mut desc = None;
101 let mut size = None;
102 let mut range = None;
103 let mut hashes = vec!();
104 for description_payload in root.children() {
105 if !description_payload.is("file", ns::JINGLE_FT) {
106 return Err(Error::ParseError("Unknown element in JingleFT description."));
107 }
108 for file_payload in description_payload.children() {
109 if file_payload.is("date", ns::JINGLE_FT) {
110 if date.is_some() {
111 return Err(Error::ParseError("File must not have more than one date."));
112 }
113 date = Some(file_payload.text());
114 } else if file_payload.is("media-type", ns::JINGLE_FT) {
115 if media_type.is_some() {
116 return Err(Error::ParseError("File must not have more than one media-type."));
117 }
118 media_type = Some(file_payload.text());
119 } else if file_payload.is("name", ns::JINGLE_FT) {
120 if name.is_some() {
121 return Err(Error::ParseError("File must not have more than one name."));
122 }
123 name = Some(file_payload.text());
124 } else if file_payload.is("desc", ns::JINGLE_FT) {
125 if desc.is_some() {
126 return Err(Error::ParseError("File must not have more than one desc."));
127 }
128 desc = Some(file_payload.text());
129 } else if file_payload.is("size", ns::JINGLE_FT) {
130 if size.is_some() {
131 return Err(Error::ParseError("File must not have more than one size."));
132 }
133 size = Some(file_payload.text().parse()?);
134 } else if file_payload.is("range", ns::JINGLE_FT) {
135 if range.is_some() {
136 return Err(Error::ParseError("File must not have more than one range."));
137 }
138 let offset = file_payload.attr("offset").unwrap_or("0").parse()?;
139 let length = match file_payload.attr("length") {
140 Some(length) => Some(length.parse()?),
141 None => None,
142 };
143 let mut range_hashes = vec!();
144 for hash_element in file_payload.children() {
145 if !hash_element.is("hash", ns::HASHES) {
146 return Err(Error::ParseError("Unknown element in JingleFT range."));
147 }
148 range_hashes.push(parse_hash(hash_element)?);
149 }
150 range = Some(Range {
151 offset: offset,
152 length: length,
153 hashes: range_hashes,
154 });
155 } else if file_payload.is("hash", ns::HASHES) {
156 hashes.push(parse_hash(file_payload)?);
157 } else {
158 return Err(Error::ParseError("Unknown element in JingleFT file."));
159 }
160 }
161 }
162
163 Ok(Description {
164 file: File {
165 date: date,
166 media_type: media_type,
167 name: name,
168 desc: desc,
169 size: size,
170 range: range,
171 hashes: hashes,
172 },
173 })
174}
175
176pub fn serialise_file(file: &File) -> Element {
177 let mut root = Element::builder("file")
178 .ns(ns::JINGLE_FT)
179 .build();
180 if let Some(ref date) = file.date {
181 root.append_child(Element::builder("date")
182 .ns(ns::JINGLE_FT)
183 .append(date.clone())
184 .build());
185 }
186 if let Some(ref media_type) = file.media_type {
187 root.append_child(Element::builder("media-type")
188 .ns(ns::JINGLE_FT)
189 .append(media_type.clone())
190 .build());
191 }
192 if let Some(ref name) = file.name {
193 root.append_child(Element::builder("name")
194 .ns(ns::JINGLE_FT)
195 .append(name.clone())
196 .build());
197 }
198 if let Some(ref desc) = file.desc {
199 root.append_child(Element::builder("desc")
200 .ns(ns::JINGLE_FT)
201 .append(desc.clone())
202 .build());
203 }
204 if let Some(ref size) = file.size {
205 root.append_child(Element::builder("size")
206 .ns(ns::JINGLE_FT)
207 .append(format!("{}", size))
208 .build());
209 }
210 if let Some(ref range) = file.range {
211 root.append_child(Element::builder("range")
212 .ns(ns::JINGLE_FT)
213 .append(range.clone())
214 .build());
215 }
216 for hash in file.hashes.clone() {
217 root.append_child(hashes::serialise(&hash));
218 }
219 root
220}
221
222pub fn serialise(desc: &Description) -> Element {
223 Element::builder("description")
224 .ns(ns::JINGLE_FT)
225 .append(serialise_file(&desc.file))
226 .build()
227}
228
229#[cfg(test)]
230mod tests {
231 use minidom::Element;
232 use jingle_ft;
233
234 #[test]
235 fn test_description() {
236 let elem: Element = r#"
237<description xmlns='urn:xmpp:jingle:apps:file-transfer:5'>
238 <file>
239 <media-type>text/plain</media-type>
240 <name>test.txt</name>
241 <date>2015-07-26T21:46:00</date>
242 <size>6144</size>
243 <hash xmlns='urn:xmpp:hashes:2'
244 algo='sha-1'>w0mcJylzCn+AfvuGdqkty2+KP48=</hash>
245 </file>
246</description>
247"#.parse().unwrap();
248
249 let desc = jingle_ft::parse_jingle_ft(&elem).unwrap();
250 assert_eq!(desc.file.media_type, Some(String::from("text/plain")));
251 assert_eq!(desc.file.name, Some(String::from("test.txt")));
252 assert_eq!(desc.file.desc, None);
253 assert_eq!(desc.file.date, Some(String::from("2015-07-26T21:46:00")));
254 assert_eq!(desc.file.size, Some(6144u64));
255 assert_eq!(desc.file.range, None);
256 assert_eq!(desc.file.hashes[0].algo, "sha-1");
257 assert_eq!(desc.file.hashes[0].hash, "w0mcJylzCn+AfvuGdqkty2+KP48=");
258 }
259
260 #[test]
261 fn test_request() {
262 let elem: Element = r#"
263<description xmlns='urn:xmpp:jingle:apps:file-transfer:5'>
264 <file>
265 <hash xmlns='urn:xmpp:hashes:2'
266 algo='sha-1'>w0mcJylzCn+AfvuGdqkty2+KP48=</hash>
267 </file>
268</description>
269"#.parse().unwrap();
270
271 let desc = jingle_ft::parse_jingle_ft(&elem).unwrap();
272 assert_eq!(desc.file.media_type, None);
273 assert_eq!(desc.file.name, None);
274 assert_eq!(desc.file.desc, None);
275 assert_eq!(desc.file.date, None);
276 assert_eq!(desc.file.size, None);
277 assert_eq!(desc.file.range, None);
278 assert_eq!(desc.file.hashes[0].algo, "sha-1");
279 assert_eq!(desc.file.hashes[0].hash, "w0mcJylzCn+AfvuGdqkty2+KP48=");
280 }
281}