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