1 extern crate tar;
2 extern crate tempdir;
3 
4 use std::fs::File;
5 use std::io::Read;
6 
7 use tempdir::TempDir;
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!(TempDir::new("tar"));
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!(TempDir::new("tar"));
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!(TempDir::new("tar"));
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!(TempDir::new("tar"));
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!(TempDir::new("tar"));
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!(TempDir::new("tar"));
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]
modify_link_just_created()184 fn modify_link_just_created() {
185     let mut ar = tar::Builder::new(Vec::new());
186 
187     let mut header = tar::Header::new_gnu();
188     header.set_size(0);
189     header.set_entry_type(tar::EntryType::Symlink);
190     t!(header.set_path("foo"));
191     t!(header.set_link_name("bar"));
192     header.set_cksum();
193     t!(ar.append(&header, &[][..]));
194 
195     let mut header = tar::Header::new_gnu();
196     header.set_size(0);
197     header.set_entry_type(tar::EntryType::Regular);
198     t!(header.set_path("bar/foo"));
199     header.set_cksum();
200     t!(ar.append(&header, &[][..]));
201 
202     let mut header = tar::Header::new_gnu();
203     header.set_size(0);
204     header.set_entry_type(tar::EntryType::Regular);
205     t!(header.set_path("foo/bar"));
206     header.set_cksum();
207     t!(ar.append(&header, &[][..]));
208 
209     let bytes = t!(ar.into_inner());
210     let mut ar = tar::Archive::new(&bytes[..]);
211 
212     let td = t!(TempDir::new("tar"));
213     t!(ar.unpack(td.path()));
214 
215     t!(File::open(td.path().join("bar/foo")));
216     t!(File::open(td.path().join("bar/bar")));
217     t!(File::open(td.path().join("foo/foo")));
218     t!(File::open(td.path().join("foo/bar")));
219 }
220 
221 #[test]
parent_paths_error()222 fn parent_paths_error() {
223     let mut ar = tar::Builder::new(Vec::new());
224 
225     let mut header = tar::Header::new_gnu();
226     header.set_size(0);
227     header.set_entry_type(tar::EntryType::Symlink);
228     t!(header.set_path("foo"));
229     t!(header.set_link_name(".."));
230     header.set_cksum();
231     t!(ar.append(&header, &[][..]));
232 
233     let mut header = tar::Header::new_gnu();
234     header.set_size(0);
235     header.set_entry_type(tar::EntryType::Regular);
236     t!(header.set_path("foo/bar"));
237     header.set_cksum();
238     t!(ar.append(&header, &[][..]));
239 
240     let bytes = t!(ar.into_inner());
241     let mut ar = tar::Archive::new(&bytes[..]);
242 
243     let td = t!(TempDir::new("tar"));
244     assert!(ar.unpack(td.path()).is_err());
245     t!(td.path().join("foo").symlink_metadata());
246     assert!(File::open(td.path().join("foo").join("bar")).is_err());
247 }
248 
249 #[test]
250 #[cfg(unix)]
good_parent_paths_ok()251 fn good_parent_paths_ok() {
252     use std::path::PathBuf;
253     let mut ar = tar::Builder::new(Vec::new());
254 
255     let mut header = tar::Header::new_gnu();
256     header.set_size(0);
257     header.set_entry_type(tar::EntryType::Symlink);
258     t!(header.set_path(PathBuf::from("foo").join("bar")));
259     t!(header.set_link_name(PathBuf::from("..").join("bar")));
260     header.set_cksum();
261     t!(ar.append(&header, &[][..]));
262 
263     let mut header = tar::Header::new_gnu();
264     header.set_size(0);
265     header.set_entry_type(tar::EntryType::Regular);
266     t!(header.set_path("bar"));
267     header.set_cksum();
268     t!(ar.append(&header, &[][..]));
269 
270     let bytes = t!(ar.into_inner());
271     let mut ar = tar::Archive::new(&bytes[..]);
272 
273     let td = t!(TempDir::new("tar"));
274     t!(ar.unpack(td.path()));
275     t!(td.path().join("foo").join("bar").read_link());
276     let dst = t!(td.path().join("foo").join("bar").canonicalize());
277     t!(File::open(dst));
278 }
279 
280 #[test]
modify_hard_link_just_created()281 fn modify_hard_link_just_created() {
282     let mut ar = tar::Builder::new(Vec::new());
283 
284     let mut header = tar::Header::new_gnu();
285     header.set_size(0);
286     header.set_entry_type(tar::EntryType::Link);
287     t!(header.set_path("foo"));
288     t!(header.set_link_name("../test"));
289     header.set_cksum();
290     t!(ar.append(&header, &[][..]));
291 
292     let mut header = tar::Header::new_gnu();
293     header.set_size(1);
294     header.set_entry_type(tar::EntryType::Regular);
295     t!(header.set_path("foo"));
296     header.set_cksum();
297     t!(ar.append(&header, &b"x"[..]));
298 
299     let bytes = t!(ar.into_inner());
300     let mut ar = tar::Archive::new(&bytes[..]);
301 
302     let td = t!(TempDir::new("tar"));
303 
304     let test = td.path().join("test");
305     t!(File::create(&test));
306 
307     let dir = td.path().join("dir");
308     assert!(ar.unpack(&dir).is_err());
309 
310     let mut contents = Vec::new();
311     t!(t!(File::open(&test)).read_to_end(&mut contents));
312     assert_eq!(contents.len(), 0);
313 }
314 
315 #[test]
modify_symlink_just_created()316 fn modify_symlink_just_created() {
317     let mut ar = tar::Builder::new(Vec::new());
318 
319     let mut header = tar::Header::new_gnu();
320     header.set_size(0);
321     header.set_entry_type(tar::EntryType::Symlink);
322     t!(header.set_path("foo"));
323     t!(header.set_link_name("../test"));
324     header.set_cksum();
325     t!(ar.append(&header, &[][..]));
326 
327     let mut header = tar::Header::new_gnu();
328     header.set_size(1);
329     header.set_entry_type(tar::EntryType::Regular);
330     t!(header.set_path("foo"));
331     header.set_cksum();
332     t!(ar.append(&header, &b"x"[..]));
333 
334     let bytes = t!(ar.into_inner());
335     let mut ar = tar::Archive::new(&bytes[..]);
336 
337     let td = t!(TempDir::new("tar"));
338 
339     let test = td.path().join("test");
340     t!(File::create(&test));
341 
342     let dir = td.path().join("dir");
343     t!(ar.unpack(&dir));
344 
345     let mut contents = Vec::new();
346     t!(t!(File::open(&test)).read_to_end(&mut contents));
347     assert_eq!(contents.len(), 0);
348 }
349