1 extern crate tar;
2 extern crate tempfile;
3 
4 use std::fs::File;
5 use std::io::Read;
6 
7 use tempfile::Builder;
8 
9 macro_rules! t {
10     ($e:expr) => {
11         match $e {
12             Ok(v) => v,
13             Err(e) => panic!("{} returned {}", stringify!($e), e),
14         }
15     };
16 }
17 
18 #[test]
absolute_symlink()19 fn absolute_symlink() {
20     let mut ar = tar::Builder::new(Vec::new());
21 
22     let mut header = tar::Header::new_gnu();
23     header.set_size(0);
24     header.set_entry_type(tar::EntryType::Symlink);
25     t!(header.set_path("foo"));
26     t!(header.set_link_name("/bar"));
27     header.set_cksum();
28     t!(ar.append(&header, &[][..]));
29 
30     let bytes = t!(ar.into_inner());
31     let mut ar = tar::Archive::new(&bytes[..]);
32 
33     let td = t!(Builder::new().prefix("tar").tempdir());
34     t!(ar.unpack(td.path()));
35 
36     t!(td.path().join("foo").symlink_metadata());
37 
38     let mut ar = tar::Archive::new(&bytes[..]);
39     let mut entries = t!(ar.entries());
40     let entry = t!(entries.next().unwrap());
41     assert_eq!(&*entry.link_name_bytes().unwrap(), b"/bar");
42 }
43 
44 #[test]
absolute_hardlink()45 fn absolute_hardlink() {
46     let td = t!(Builder::new().prefix("tar").tempdir());
47     let mut ar = tar::Builder::new(Vec::new());
48 
49     let mut header = tar::Header::new_gnu();
50     header.set_size(0);
51     header.set_entry_type(tar::EntryType::Regular);
52     t!(header.set_path("foo"));
53     header.set_cksum();
54     t!(ar.append(&header, &[][..]));
55 
56     let mut header = tar::Header::new_gnu();
57     header.set_size(0);
58     header.set_entry_type(tar::EntryType::Link);
59     t!(header.set_path("bar"));
60     // This absolute path under tempdir will be created at unpack time
61     t!(header.set_link_name(td.path().join("foo")));
62     header.set_cksum();
63     t!(ar.append(&header, &[][..]));
64 
65     let bytes = t!(ar.into_inner());
66     let mut ar = tar::Archive::new(&bytes[..]);
67 
68     t!(ar.unpack(td.path()));
69     t!(td.path().join("foo").metadata());
70     t!(td.path().join("bar").metadata());
71 }
72 
73 #[test]
relative_hardlink()74 fn relative_hardlink() {
75     let mut ar = tar::Builder::new(Vec::new());
76 
77     let mut header = tar::Header::new_gnu();
78     header.set_size(0);
79     header.set_entry_type(tar::EntryType::Regular);
80     t!(header.set_path("foo"));
81     header.set_cksum();
82     t!(ar.append(&header, &[][..]));
83 
84     let mut header = tar::Header::new_gnu();
85     header.set_size(0);
86     header.set_entry_type(tar::EntryType::Link);
87     t!(header.set_path("bar"));
88     t!(header.set_link_name("foo"));
89     header.set_cksum();
90     t!(ar.append(&header, &[][..]));
91 
92     let bytes = t!(ar.into_inner());
93     let mut ar = tar::Archive::new(&bytes[..]);
94 
95     let td = t!(Builder::new().prefix("tar").tempdir());
96     t!(ar.unpack(td.path()));
97     t!(td.path().join("foo").metadata());
98     t!(td.path().join("bar").metadata());
99 }
100 
101 #[test]
absolute_link_deref_error()102 fn absolute_link_deref_error() {
103     let mut ar = tar::Builder::new(Vec::new());
104 
105     let mut header = tar::Header::new_gnu();
106     header.set_size(0);
107     header.set_entry_type(tar::EntryType::Symlink);
108     t!(header.set_path("foo"));
109     t!(header.set_link_name("/"));
110     header.set_cksum();
111     t!(ar.append(&header, &[][..]));
112 
113     let mut header = tar::Header::new_gnu();
114     header.set_size(0);
115     header.set_entry_type(tar::EntryType::Regular);
116     t!(header.set_path("foo/bar"));
117     header.set_cksum();
118     t!(ar.append(&header, &[][..]));
119 
120     let bytes = t!(ar.into_inner());
121     let mut ar = tar::Archive::new(&bytes[..]);
122 
123     let td = t!(Builder::new().prefix("tar").tempdir());
124     assert!(ar.unpack(td.path()).is_err());
125     t!(td.path().join("foo").symlink_metadata());
126     assert!(File::open(td.path().join("foo").join("bar")).is_err());
127 }
128 
129 #[test]
relative_link_deref_error()130 fn relative_link_deref_error() {
131     let mut ar = tar::Builder::new(Vec::new());
132 
133     let mut header = tar::Header::new_gnu();
134     header.set_size(0);
135     header.set_entry_type(tar::EntryType::Symlink);
136     t!(header.set_path("foo"));
137     t!(header.set_link_name("../../../../"));
138     header.set_cksum();
139     t!(ar.append(&header, &[][..]));
140 
141     let mut header = tar::Header::new_gnu();
142     header.set_size(0);
143     header.set_entry_type(tar::EntryType::Regular);
144     t!(header.set_path("foo/bar"));
145     header.set_cksum();
146     t!(ar.append(&header, &[][..]));
147 
148     let bytes = t!(ar.into_inner());
149     let mut ar = tar::Archive::new(&bytes[..]);
150 
151     let td = t!(Builder::new().prefix("tar").tempdir());
152     assert!(ar.unpack(td.path()).is_err());
153     t!(td.path().join("foo").symlink_metadata());
154     assert!(File::open(td.path().join("foo").join("bar")).is_err());
155 }
156 
157 #[test]
158 #[cfg(unix)]
directory_maintains_permissions()159 fn directory_maintains_permissions() {
160     use ::std::os::unix::fs::PermissionsExt;
161 
162     let mut ar = tar::Builder::new(Vec::new());
163 
164     let mut header = tar::Header::new_gnu();
165     header.set_size(0);
166     header.set_entry_type(tar::EntryType::Directory);
167     t!(header.set_path("foo"));
168     header.set_mode(0o777);
169     header.set_cksum();
170     t!(ar.append(&header, &[][..]));
171 
172     let bytes = t!(ar.into_inner());
173     let mut ar = tar::Archive::new(&bytes[..]);
174 
175     let td = t!(Builder::new().prefix("tar").tempdir());
176     t!(ar.unpack(td.path()));
177     let f = t!(File::open(td.path().join("foo")));
178     let md = t!(f.metadata());
179     assert!(md.is_dir());
180     assert_eq!(md.permissions().mode(), 0o40777);
181 }
182 
183 #[test]
184 #[cfg(not(windows))] // dangling symlinks have weird permissions
modify_link_just_created()185 fn modify_link_just_created() {
186     let mut ar = tar::Builder::new(Vec::new());
187 
188     let mut header = tar::Header::new_gnu();
189     header.set_size(0);
190     header.set_entry_type(tar::EntryType::Symlink);
191     t!(header.set_path("foo"));
192     t!(header.set_link_name("bar"));
193     header.set_cksum();
194     t!(ar.append(&header, &[][..]));
195 
196     let mut header = tar::Header::new_gnu();
197     header.set_size(0);
198     header.set_entry_type(tar::EntryType::Regular);
199     t!(header.set_path("bar/foo"));
200     header.set_cksum();
201     t!(ar.append(&header, &[][..]));
202 
203     let mut header = tar::Header::new_gnu();
204     header.set_size(0);
205     header.set_entry_type(tar::EntryType::Regular);
206     t!(header.set_path("foo/bar"));
207     header.set_cksum();
208     t!(ar.append(&header, &[][..]));
209 
210     let bytes = t!(ar.into_inner());
211     let mut ar = tar::Archive::new(&bytes[..]);
212 
213     let td = t!(Builder::new().prefix("tar").tempdir());
214     t!(ar.unpack(td.path()));
215 
216     t!(File::open(td.path().join("bar/foo")));
217     t!(File::open(td.path().join("bar/bar")));
218     t!(File::open(td.path().join("foo/foo")));
219     t!(File::open(td.path().join("foo/bar")));
220 }
221 
222 #[test]
parent_paths_error()223 fn parent_paths_error() {
224     let mut ar = tar::Builder::new(Vec::new());
225 
226     let mut header = tar::Header::new_gnu();
227     header.set_size(0);
228     header.set_entry_type(tar::EntryType::Symlink);
229     t!(header.set_path("foo"));
230     t!(header.set_link_name(".."));
231     header.set_cksum();
232     t!(ar.append(&header, &[][..]));
233 
234     let mut header = tar::Header::new_gnu();
235     header.set_size(0);
236     header.set_entry_type(tar::EntryType::Regular);
237     t!(header.set_path("foo/bar"));
238     header.set_cksum();
239     t!(ar.append(&header, &[][..]));
240 
241     let bytes = t!(ar.into_inner());
242     let mut ar = tar::Archive::new(&bytes[..]);
243 
244     let td = t!(Builder::new().prefix("tar").tempdir());
245     assert!(ar.unpack(td.path()).is_err());
246     t!(td.path().join("foo").symlink_metadata());
247     assert!(File::open(td.path().join("foo").join("bar")).is_err());
248 }
249 
250 #[test]
251 #[cfg(unix)]
good_parent_paths_ok()252 fn good_parent_paths_ok() {
253     use std::path::PathBuf;
254     let mut ar = tar::Builder::new(Vec::new());
255 
256     let mut header = tar::Header::new_gnu();
257     header.set_size(0);
258     header.set_entry_type(tar::EntryType::Symlink);
259     t!(header.set_path(PathBuf::from("foo").join("bar")));
260     t!(header.set_link_name(PathBuf::from("..").join("bar")));
261     header.set_cksum();
262     t!(ar.append(&header, &[][..]));
263 
264     let mut header = tar::Header::new_gnu();
265     header.set_size(0);
266     header.set_entry_type(tar::EntryType::Regular);
267     t!(header.set_path("bar"));
268     header.set_cksum();
269     t!(ar.append(&header, &[][..]));
270 
271     let bytes = t!(ar.into_inner());
272     let mut ar = tar::Archive::new(&bytes[..]);
273 
274     let td = t!(Builder::new().prefix("tar").tempdir());
275     t!(ar.unpack(td.path()));
276     t!(td.path().join("foo").join("bar").read_link());
277     let dst = t!(td.path().join("foo").join("bar").canonicalize());
278     t!(File::open(dst));
279 }
280 
281 #[test]
modify_hard_link_just_created()282 fn modify_hard_link_just_created() {
283     let mut ar = tar::Builder::new(Vec::new());
284 
285     let mut header = tar::Header::new_gnu();
286     header.set_size(0);
287     header.set_entry_type(tar::EntryType::Link);
288     t!(header.set_path("foo"));
289     t!(header.set_link_name("../test"));
290     header.set_cksum();
291     t!(ar.append(&header, &[][..]));
292 
293     let mut header = tar::Header::new_gnu();
294     header.set_size(1);
295     header.set_entry_type(tar::EntryType::Regular);
296     t!(header.set_path("foo"));
297     header.set_cksum();
298     t!(ar.append(&header, &b"x"[..]));
299 
300     let bytes = t!(ar.into_inner());
301     let mut ar = tar::Archive::new(&bytes[..]);
302 
303     let td = t!(Builder::new().prefix("tar").tempdir());
304 
305     let test = td.path().join("test");
306     t!(File::create(&test));
307 
308     let dir = td.path().join("dir");
309     assert!(ar.unpack(&dir).is_err());
310 
311     let mut contents = Vec::new();
312     t!(t!(File::open(&test)).read_to_end(&mut contents));
313     assert_eq!(contents.len(), 0);
314 }
315 
316 #[test]
modify_symlink_just_created()317 fn modify_symlink_just_created() {
318     let mut ar = tar::Builder::new(Vec::new());
319 
320     let mut header = tar::Header::new_gnu();
321     header.set_size(0);
322     header.set_entry_type(tar::EntryType::Symlink);
323     t!(header.set_path("foo"));
324     t!(header.set_link_name("../test"));
325     header.set_cksum();
326     t!(ar.append(&header, &[][..]));
327 
328     let mut header = tar::Header::new_gnu();
329     header.set_size(1);
330     header.set_entry_type(tar::EntryType::Regular);
331     t!(header.set_path("foo"));
332     header.set_cksum();
333     t!(ar.append(&header, &b"x"[..]));
334 
335     let bytes = t!(ar.into_inner());
336     let mut ar = tar::Archive::new(&bytes[..]);
337 
338     let td = t!(Builder::new().prefix("tar").tempdir());
339 
340     let test = td.path().join("test");
341     t!(File::create(&test));
342 
343     let dir = td.path().join("dir");
344     t!(ar.unpack(&dir));
345 
346     let mut contents = Vec::new();
347     t!(t!(File::open(&test)).read_to_end(&mut contents));
348     assert_eq!(contents.len(), 0);
349 }
350