2 * Copyright (c) 2010-2012 Michihiro NAKAJIMA
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 __FBSDID("$FreeBSD$");
29 #if defined(_WIN32) && !defined(__CYGWIN__)
30 # if !defined(__BORLANDC__)
31 # define getcwd _getcwd
36 * Test if the current filesystem is mounted with noatime option.
41 const char *fn = "fs_noatime";
43 #if defined(_WIN32) && !defined(CYGWIN)
48 r = systemf("fsutil behavior query disableLastAccess > query_atime");
50 buff = slurpfile(NULL, "query_atime");
53 while(*ptr != '\0' && !isdigit(*ptr)) {
59 } else if (*ptr == '1' || *ptr == '2') {
67 if (!assertMakeFile(fn, 0666, "a"))
69 if (!assertUtimes(fn, 1, 0, 1, 0))
71 /* Test the file contents in order to update its atime. */
72 if (!assertTextFileContents("a", fn))
74 if (stat(fn, &st) != 0)
76 /* Is atime updated? */
86 struct archive_entry *ae;
88 char *initial_cwd, *cwd;
92 #if defined(_WIN32) && !defined(__CYGWIN__)
93 wchar_t *wcwd, *wp, *fullpath;
96 assertMakeDir("dir1", 0755);
97 assertMakeFile("dir1/file1", 0644, "0123456789");
98 assertMakeFile("dir1/file2", 0644, "hello world");
99 assertMakeDir("dir1/sub1", 0755);
100 assertMakeFile("dir1/sub1/file1", 0644, "0123456789");
101 assertMakeDir("dir1/sub2", 0755);
102 assertMakeFile("dir1/sub2/file1", 0644, "0123456789");
103 assertMakeFile("dir1/sub2/file2", 0644, "0123456789");
104 assertMakeDir("dir1/sub2/sub1", 0755);
105 assertMakeDir("dir1/sub2/sub2", 0755);
106 assertMakeDir("dir1/sub2/sub3", 0755);
107 assertMakeFile("dir1/sub2/sub3/file", 0644, "xyz");
110 assert((ae = archive_entry_new()) != NULL);
111 assert((a = archive_read_disk_new()) != NULL);
112 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open(a, "dir1"));
114 while (file_count--) {
115 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header2(a, ae));
116 if (strcmp(archive_entry_pathname(ae), "dir1") == 0) {
117 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
118 assertEqualInt(1, archive_read_disk_can_descend(a));
119 } else if (strcmp(archive_entry_pathname(ae),
120 "dir1/file1") == 0) {
121 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
122 assertEqualInt(archive_entry_size(ae), 10);
123 assertEqualIntA(a, ARCHIVE_OK,
124 archive_read_data_block(a, &p, &size, &offset));
125 assertEqualInt((int)size, 10);
126 assertEqualInt((int)offset, 0);
127 assertEqualMem(p, "0123456789", 10);
128 assertEqualInt(ARCHIVE_EOF,
129 archive_read_data_block(a, &p, &size, &offset));
130 assertEqualInt((int)size, 0);
131 assertEqualInt((int)offset, 10);
132 assertEqualInt(0, archive_read_disk_can_descend(a));
133 } else if (strcmp(archive_entry_pathname(ae),
134 "dir1/file2") == 0) {
135 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
136 assertEqualInt(archive_entry_size(ae), 11);
137 assertEqualIntA(a, ARCHIVE_OK,
138 archive_read_data_block(a, &p, &size, &offset));
139 assertEqualInt((int)size, 11);
140 assertEqualInt((int)offset, 0);
141 assertEqualMem(p, "hello world", 11);
142 assertEqualInt(ARCHIVE_EOF,
143 archive_read_data_block(a, &p, &size, &offset));
144 assertEqualInt((int)size, 0);
145 assertEqualInt((int)offset, 11);
146 assertEqualInt(0, archive_read_disk_can_descend(a));
147 } else if (strcmp(archive_entry_pathname(ae),
149 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
150 assertEqualInt(1, archive_read_disk_can_descend(a));
151 } else if (strcmp(archive_entry_pathname(ae),
152 "dir1/sub1/file1") == 0) {
153 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
154 assertEqualInt(archive_entry_size(ae), 10);
155 assertEqualIntA(a, ARCHIVE_OK,
156 archive_read_data_block(a, &p, &size, &offset));
157 assertEqualInt((int)size, 10);
158 assertEqualInt((int)offset, 0);
159 assertEqualMem(p, "0123456789", 10);
160 assertEqualInt(ARCHIVE_EOF,
161 archive_read_data_block(a, &p, &size, &offset));
162 assertEqualInt((int)size, 0);
163 assertEqualInt((int)offset, 10);
164 assertEqualInt(0, archive_read_disk_can_descend(a));
165 } else if (strcmp(archive_entry_pathname(ae),
167 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
168 assertEqualInt(1, archive_read_disk_can_descend(a));
169 } else if (strcmp(archive_entry_pathname(ae),
170 "dir1/sub2/file1") == 0) {
171 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
172 assertEqualInt(archive_entry_size(ae), 10);
173 assertEqualIntA(a, ARCHIVE_OK,
174 archive_read_data_block(a, &p, &size, &offset));
175 assertEqualInt((int)size, 10);
176 assertEqualInt((int)offset, 0);
177 assertEqualMem(p, "0123456789", 10);
178 assertEqualInt(ARCHIVE_EOF,
179 archive_read_data_block(a, &p, &size, &offset));
180 assertEqualInt((int)size, 0);
181 assertEqualInt((int)offset, 10);
182 assertEqualInt(0, archive_read_disk_can_descend(a));
183 } else if (strcmp(archive_entry_pathname(ae),
184 "dir1/sub2/file2") == 0) {
185 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
186 assertEqualInt(archive_entry_size(ae), 10);
187 assertEqualIntA(a, ARCHIVE_OK,
188 archive_read_data_block(a, &p, &size, &offset));
189 assertEqualInt((int)size, 10);
190 assertEqualInt((int)offset, 0);
191 assertEqualMem(p, "0123456789", 10);
192 assertEqualInt(ARCHIVE_EOF,
193 archive_read_data_block(a, &p, &size, &offset));
194 assertEqualInt((int)size, 0);
195 assertEqualInt((int)offset, 10);
196 assertEqualInt(0, archive_read_disk_can_descend(a));
197 } else if (strcmp(archive_entry_pathname(ae),
198 "dir1/sub2/sub1") == 0) {
199 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
200 assertEqualInt(1, archive_read_disk_can_descend(a));
201 } else if (strcmp(archive_entry_pathname(ae),
202 "dir1/sub2/sub2") == 0) {
203 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
204 assertEqualInt(1, archive_read_disk_can_descend(a));
205 } else if (strcmp(archive_entry_pathname(ae),
206 "dir1/sub2/sub3") == 0) {
207 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
208 assertEqualInt(1, archive_read_disk_can_descend(a));
209 } else if (strcmp(archive_entry_pathname(ae),
210 "dir1/sub2/sub3/file") == 0) {
211 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
212 assertEqualInt(archive_entry_size(ae), 3);
213 assertEqualIntA(a, ARCHIVE_OK,
214 archive_read_data_block(a, &p, &size, &offset));
215 assertEqualInt((int)size, 3);
216 assertEqualInt((int)offset, 0);
217 assertEqualMem(p, "xyz", 3);
218 assertEqualInt(ARCHIVE_EOF,
219 archive_read_data_block(a, &p, &size, &offset));
220 assertEqualInt((int)size, 0);
221 assertEqualInt((int)offset, 3);
222 assertEqualInt(0, archive_read_disk_can_descend(a));
224 if (archive_entry_filetype(ae) == AE_IFDIR) {
225 /* Descend into the current object */
226 assertEqualIntA(a, ARCHIVE_OK,
227 archive_read_disk_descend(a));
230 /* There is no entry. */
231 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header2(a, ae));
233 /* Close the disk object. */
234 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
237 * Test that call archive_read_disk_open_w, wchar_t version.
239 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open_w(a, L"dir1"));
242 while (file_count--) {
243 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header2(a, ae));
244 if (wcscmp(archive_entry_pathname_w(ae), L"dir1") == 0) {
245 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
246 assertEqualInt(1, archive_read_disk_can_descend(a));
247 } else if (wcscmp(archive_entry_pathname_w(ae),
248 L"dir1/file1") == 0) {
249 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
250 assertEqualInt(archive_entry_size(ae), 10);
251 assertEqualIntA(a, ARCHIVE_OK,
252 archive_read_data_block(a, &p, &size, &offset));
253 assertEqualInt((int)size, 10);
254 assertEqualInt((int)offset, 0);
255 assertEqualMem(p, "0123456789", 10);
256 assertEqualInt(ARCHIVE_EOF,
257 archive_read_data_block(a, &p, &size, &offset));
258 assertEqualInt((int)size, 0);
259 assertEqualInt((int)offset, 10);
260 assertEqualInt(0, archive_read_disk_can_descend(a));
261 } else if (wcscmp(archive_entry_pathname_w(ae),
262 L"dir1/file2") == 0) {
263 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
264 assertEqualInt(archive_entry_size(ae), 11);
265 assertEqualIntA(a, ARCHIVE_OK,
266 archive_read_data_block(a, &p, &size, &offset));
267 assertEqualInt((int)size, 11);
268 assertEqualInt((int)offset, 0);
269 assertEqualMem(p, "hello world", 11);
270 assertEqualInt(ARCHIVE_EOF,
271 archive_read_data_block(a, &p, &size, &offset));
272 assertEqualInt((int)size, 0);
273 assertEqualInt((int)offset, 11);
274 assertEqualInt(0, archive_read_disk_can_descend(a));
275 } else if (wcscmp(archive_entry_pathname_w(ae),
276 L"dir1/sub1") == 0) {
277 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
278 assertEqualInt(1, archive_read_disk_can_descend(a));
279 } else if (wcscmp(archive_entry_pathname_w(ae),
280 L"dir1/sub1/file1") == 0) {
281 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
282 assertEqualInt(archive_entry_size(ae), 10);
283 assertEqualIntA(a, ARCHIVE_OK,
284 archive_read_data_block(a, &p, &size, &offset));
285 assertEqualInt((int)size, 10);
286 assertEqualInt((int)offset, 0);
287 assertEqualMem(p, "0123456789", 10);
288 assertEqualInt(ARCHIVE_EOF,
289 archive_read_data_block(a, &p, &size, &offset));
290 assertEqualInt((int)size, 0);
291 assertEqualInt((int)offset, 10);
292 assertEqualInt(0, archive_read_disk_can_descend(a));
293 } else if (wcscmp(archive_entry_pathname_w(ae),
294 L"dir1/sub2") == 0) {
295 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
296 assertEqualInt(1, archive_read_disk_can_descend(a));
297 } else if (wcscmp(archive_entry_pathname_w(ae),
298 L"dir1/sub2/file1") == 0) {
299 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
300 assertEqualInt(archive_entry_size(ae), 10);
301 assertEqualIntA(a, ARCHIVE_OK,
302 archive_read_data_block(a, &p, &size, &offset));
303 assertEqualInt((int)size, 10);
304 assertEqualInt((int)offset, 0);
305 assertEqualMem(p, "0123456789", 10);
306 assertEqualInt(ARCHIVE_EOF,
307 archive_read_data_block(a, &p, &size, &offset));
308 assertEqualInt((int)size, 0);
309 assertEqualInt((int)offset, 10);
310 assertEqualInt(0, archive_read_disk_can_descend(a));
311 } else if (wcscmp(archive_entry_pathname_w(ae),
312 L"dir1/sub2/file2") == 0) {
313 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
314 assertEqualInt(archive_entry_size(ae), 10);
315 assertEqualIntA(a, ARCHIVE_OK,
316 archive_read_data_block(a, &p, &size, &offset));
317 assertEqualInt((int)size, 10);
318 assertEqualInt((int)offset, 0);
319 assertEqualMem(p, "0123456789", 10);
320 assertEqualInt(ARCHIVE_EOF,
321 archive_read_data_block(a, &p, &size, &offset));
322 assertEqualInt((int)size, 0);
323 assertEqualInt((int)offset, 10);
324 assertEqualInt(0, archive_read_disk_can_descend(a));
325 } else if (wcscmp(archive_entry_pathname_w(ae),
326 L"dir1/sub2/sub1") == 0) {
327 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
328 assertEqualInt(1, archive_read_disk_can_descend(a));
329 } else if (wcscmp(archive_entry_pathname_w(ae),
330 L"dir1/sub2/sub2") == 0) {
331 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
332 assertEqualInt(1, archive_read_disk_can_descend(a));
333 } else if (wcscmp(archive_entry_pathname_w(ae),
334 L"dir1/sub2/sub3") == 0) {
335 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
336 assertEqualInt(1, archive_read_disk_can_descend(a));
337 } else if (wcscmp(archive_entry_pathname_w(ae),
338 L"dir1/sub2/sub3/file") == 0) {
339 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
340 assertEqualInt(archive_entry_size(ae), 3);
341 assertEqualIntA(a, ARCHIVE_OK,
342 archive_read_data_block(a, &p, &size, &offset));
343 assertEqualInt((int)size, 3);
344 assertEqualInt((int)offset, 0);
345 assertEqualMem(p, "xyz", 3);
346 assertEqualInt(ARCHIVE_EOF,
347 archive_read_data_block(a, &p, &size, &offset));
348 assertEqualInt((int)size, 0);
349 assertEqualInt((int)offset, 3);
350 assertEqualInt(0, archive_read_disk_can_descend(a));
352 if (archive_entry_filetype(ae) == AE_IFDIR) {
353 /* Descend into the current object */
354 assertEqualIntA(a, ARCHIVE_OK,
355 archive_read_disk_descend(a));
358 /* There is no entry. */
359 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header2(a, ae));
361 /* Close the disk object. */
362 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
365 * Test that call archive_read_disk_open with a regular file.
367 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open(a, "dir1/file1"));
370 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header2(a, ae));
371 assertEqualInt(0, archive_read_disk_can_descend(a));
372 assertEqualString(archive_entry_pathname(ae), "dir1/file1");
373 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
374 assertEqualInt(archive_entry_size(ae), 10);
375 assertEqualIntA(a, ARCHIVE_OK,
376 archive_read_data_block(a, &p, &size, &offset));
377 assertEqualInt((int)size, 10);
378 assertEqualInt((int)offset, 0);
379 assertEqualMem(p, "0123456789", 10);
381 /* There is no entry. */
382 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header2(a, ae));
384 /* Close the disk object. */
385 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
388 #if defined(_WIN32) && !defined(__CYGWIN__)
390 * Test for wildcard '*' or '?'
392 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open(a, "dir1/*1"));
395 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header2(a, ae));
396 assertEqualInt(0, archive_read_disk_can_descend(a));
397 assertEqualString(archive_entry_pathname(ae), "dir1/file1");
398 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
399 assertEqualInt(archive_entry_size(ae), 10);
400 assertEqualIntA(a, ARCHIVE_OK,
401 archive_read_data_block(a, &p, &size, &offset));
402 assertEqualInt((int)size, 10);
403 assertEqualInt((int)offset, 0);
404 assertEqualMem(p, "0123456789", 10);
407 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header2(a, ae));
408 assertEqualInt(1, archive_read_disk_can_descend(a));
409 assertEqualString(archive_entry_pathname(ae), "dir1/sub1");
410 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
412 /* Descend into the current object */
413 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_descend(a));
415 /* dir1/sub1/file1 */
416 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header2(a, ae));
417 assertEqualInt(0, archive_read_disk_can_descend(a));
418 assertEqualString(archive_entry_pathname(ae), "dir1/sub1/file1");
419 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
420 assertEqualInt(archive_entry_size(ae), 10);
421 assertEqualIntA(a, ARCHIVE_OK,
422 archive_read_data_block(a, &p, &size, &offset));
423 assertEqualInt((int)size, 10);
424 assertEqualInt((int)offset, 0);
425 assertEqualMem(p, "0123456789", 10);
427 /* There is no entry. */
428 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header2(a, ae));
430 /* Close the disk object. */
431 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
434 * Test for a full-path beginning with "//?/"
436 wcwd = _wgetcwd(NULL, 0);
437 fullpath = malloc(sizeof(wchar_t) * (wcslen(wcwd) + 32));
438 wcscpy(fullpath, L"//?/");
439 wcscat(fullpath, wcwd);
440 wcscat(fullpath, L"/dir1/file1");
442 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open_w(a, fullpath));
443 while ((wcwd = wcschr(fullpath, L'\\')) != NULL)
447 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header2(a, ae));
448 assertEqualInt(0, archive_read_disk_can_descend(a));
449 assertEqualWString(archive_entry_pathname_w(ae), fullpath);
450 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
451 assertEqualInt(archive_entry_size(ae), 10);
452 assertEqualIntA(a, ARCHIVE_OK,
453 archive_read_data_block(a, &p, &size, &offset));
454 assertEqualInt((int)size, 10);
455 assertEqualInt((int)offset, 0);
456 assertEqualMem(p, "0123456789", 10);
458 /* There is no entry. */
459 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header2(a, ae));
461 /* Close the disk object. */
462 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
466 * Test for wild card '*' or '?' with "//?/" prefix.
468 wcwd = _wgetcwd(NULL, 0);
469 fullpath = malloc(sizeof(wchar_t) * (wcslen(wcwd) + 32));
470 wcscpy(fullpath, L"//?/");
471 wcscat(fullpath, wcwd);
472 wcscat(fullpath, L"/dir1/*1");
474 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open_w(a, fullpath));
475 while ((wcwd = wcschr(fullpath, L'\\')) != NULL)
479 wp = wcsrchr(fullpath, L'/');
480 wcscpy(wp+1, L"file1");
481 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header2(a, ae));
482 assertEqualInt(0, archive_read_disk_can_descend(a));
483 assertEqualWString(archive_entry_pathname_w(ae), fullpath);
484 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
485 assertEqualInt(archive_entry_size(ae), 10);
486 assertEqualIntA(a, ARCHIVE_OK,
487 archive_read_data_block(a, &p, &size, &offset));
488 assertEqualInt((int)size, 10);
489 assertEqualInt((int)offset, 0);
490 assertEqualMem(p, "0123456789", 10);
493 wcscpy(wp+1, L"sub1");
494 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header2(a, ae));
495 assertEqualInt(1, archive_read_disk_can_descend(a));
496 assertEqualWString(archive_entry_pathname_w(ae), fullpath);
497 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
499 /* Descend into the current object */
500 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_descend(a));
502 /* dir1/sub1/file1 */
503 wcscpy(wp+1, L"sub1/file1");
504 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header2(a, ae));
505 assertEqualInt(0, archive_read_disk_can_descend(a));
506 assertEqualWString(archive_entry_pathname_w(ae), fullpath);
507 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
508 assertEqualInt(archive_entry_size(ae), 10);
509 assertEqualIntA(a, ARCHIVE_OK,
510 archive_read_data_block(a, &p, &size, &offset));
511 assertEqualInt((int)size, 10);
512 assertEqualInt((int)offset, 0);
513 assertEqualMem(p, "0123456789", 10);
515 /* There is no entry. */
516 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header2(a, ae));
518 /* Close the disk object. */
519 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
525 * We should be on the initial directory where we performed
526 * archive_read_disk_new() after we perform archive_read_free()
527 * even if we broke off the directory traversals.
530 /* Save current working directory. */
532 initial_cwd = getcwd(NULL, PATH_MAX);/* Solaris getcwd needs the size. */
534 initial_cwd = getcwd(NULL, 0);
537 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open(a, "dir1"));
539 /* Step in a deep directory. */
541 while (file_count--) {
542 assertEqualIntA(a, ARCHIVE_OK,
543 archive_read_next_header2(a, ae));
544 if (strcmp(archive_entry_pathname(ae),
545 "dir1/sub1/file1") == 0)
547 * We are on an another directory at this time.
550 if (archive_entry_filetype(ae) == AE_IFDIR) {
551 /* Descend into the current object */
552 assertEqualIntA(a, ARCHIVE_OK,
553 archive_read_disk_descend(a));
556 /* Destroy the disk object. */
557 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
559 /* We should be on the initial working directory. */
561 "Current working directory does not return to the initial"
564 cwd = getcwd(NULL, PATH_MAX);/* Solaris getcwd needs the size. */
566 cwd = getcwd(NULL, 0);
568 assertEqualString(initial_cwd, cwd);
572 archive_entry_free(ae);
576 test_symlink_hybrid(void)
579 struct archive_entry *ae;
586 skipping("Can't test symlinks on this filesystem");
591 * Create a sample archive.
593 assertMakeDir("h", 0755);
595 assertMakeDir("d1", 0755);
596 assertMakeSymlink("ld1", "d1", 1);
597 assertMakeFile("d1/file1", 0644, "d1/file1");
598 assertMakeFile("d1/file2", 0644, "d1/file2");
599 assertMakeSymlink("d1/link1", "file1", 0);
600 assertMakeSymlink("d1/linkX", "fileX", 0);
601 assertMakeSymlink("link2", "d1/file2", 0);
602 assertMakeSymlink("linkY", "d1/fileY", 0);
605 assert((ae = archive_entry_new()) != NULL);
606 assert((a = archive_read_disk_new()) != NULL);
607 assertEqualIntA(a, ARCHIVE_OK,
608 archive_read_disk_set_symlink_hybrid(a));
611 * Specified file is a symbolic link file.
613 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open(a, "h/ld1"));
616 while (file_count--) {
617 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header2(a, ae));
618 if (strcmp(archive_entry_pathname(ae), "h/ld1") == 0) {
619 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
620 } else if (strcmp(archive_entry_pathname(ae),
621 "h/ld1/file1") == 0) {
622 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
623 assertEqualInt(archive_entry_size(ae), 8);
624 assertEqualIntA(a, ARCHIVE_OK,
625 archive_read_data_block(a, &p, &size, &offset));
626 assertEqualInt((int)size, 8);
627 assertEqualInt((int)offset, 0);
628 assertEqualMem(p, "d1/file1", 8);
629 assertEqualInt(ARCHIVE_EOF,
630 archive_read_data_block(a, &p, &size, &offset));
631 assertEqualInt((int)size, 0);
632 assertEqualInt((int)offset, 8);
633 } else if (strcmp(archive_entry_pathname(ae),
634 "h/ld1/file2") == 0) {
635 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
636 assertEqualInt(archive_entry_size(ae), 8);
637 assertEqualIntA(a, ARCHIVE_OK,
638 archive_read_data_block(a, &p, &size, &offset));
639 assertEqualInt((int)size, 8);
640 assertEqualInt((int)offset, 0);
641 assertEqualMem(p, "d1/file2", 8);
642 assertEqualInt(ARCHIVE_EOF,
643 archive_read_data_block(a, &p, &size, &offset));
644 assertEqualInt((int)size, 0);
645 assertEqualInt((int)offset, 8);
646 } else if (strcmp(archive_entry_pathname(ae),
647 "h/ld1/link1") == 0) {
648 assertEqualInt(archive_entry_filetype(ae), AE_IFLNK);
649 } else if (strcmp(archive_entry_pathname(ae),
650 "h/ld1/linkX") == 0) {
651 assertEqualInt(archive_entry_filetype(ae), AE_IFLNK);
653 if (archive_entry_filetype(ae) == AE_IFDIR) {
654 /* Descend into the current object */
655 assertEqualIntA(a, ARCHIVE_OK,
656 archive_read_disk_descend(a));
659 /* There is no entry. */
660 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header2(a, ae));
661 /* Close the disk object. */
662 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
665 * Specified file is a directory and it has symbolic files.
667 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open(a, "h"));
670 while (file_count--) {
671 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header2(a, ae));
672 if (strcmp(archive_entry_pathname(ae), "h") == 0) {
673 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
674 } else if (strcmp(archive_entry_pathname(ae), "h/d1") == 0) {
675 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
676 } else if (strcmp(archive_entry_pathname(ae),
677 "h/d1/file1") == 0) {
678 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
679 assertEqualInt(archive_entry_size(ae), 8);
680 assertEqualIntA(a, ARCHIVE_OK,
681 archive_read_data_block(a, &p, &size, &offset));
682 assertEqualInt((int)size, 8);
683 assertEqualInt((int)offset, 0);
684 assertEqualMem(p, "d1/file1", 8);
685 assertEqualInt(ARCHIVE_EOF,
686 archive_read_data_block(a, &p, &size, &offset));
687 assertEqualInt((int)size, 0);
688 assertEqualInt((int)offset, 8);
689 } else if (strcmp(archive_entry_pathname(ae),
690 "h/d1/file2") == 0) {
691 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
692 assertEqualInt(archive_entry_size(ae), 8);
693 assertEqualIntA(a, ARCHIVE_OK,
694 archive_read_data_block(a, &p, &size, &offset));
695 assertEqualInt((int)size, 8);
696 assertEqualInt((int)offset, 0);
697 assertEqualMem(p, "d1/file2", 8);
698 assertEqualInt(ARCHIVE_EOF,
699 archive_read_data_block(a, &p, &size, &offset));
700 assertEqualInt((int)size, 0);
701 assertEqualInt((int)offset, 8);
702 } else if (strcmp(archive_entry_pathname(ae), "h/ld1") == 0) {
703 assertEqualInt(archive_entry_filetype(ae), AE_IFLNK);
704 } else if (strcmp(archive_entry_pathname(ae),
705 "h/d1/link1") == 0) {
706 assertEqualInt(archive_entry_filetype(ae), AE_IFLNK);
707 } else if (strcmp(archive_entry_pathname(ae),
708 "h/d1/linkX") == 0) {
709 assertEqualInt(archive_entry_filetype(ae), AE_IFLNK);
710 } else if (strcmp(archive_entry_pathname(ae),
712 assertEqualInt(archive_entry_filetype(ae), AE_IFLNK);
713 } else if (strcmp(archive_entry_pathname(ae),
715 assertEqualInt(archive_entry_filetype(ae), AE_IFLNK);
717 if (archive_entry_filetype(ae) == AE_IFDIR) {
718 /* Descend into the current object */
719 assertEqualIntA(a, ARCHIVE_OK,
720 archive_read_disk_descend(a));
723 /* There is no entry. */
724 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header2(a, ae));
725 /* Close the disk object. */
726 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
727 /* Destroy the disk object. */
728 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
729 archive_entry_free(ae);
733 test_symlink_logical(void)
736 struct archive_entry *ae;
743 skipping("Can't test symlinks on this filesystem");
748 * Create a sample archive.
750 assertMakeDir("l", 0755);
752 assertMakeDir("d1", 0755);
753 assertMakeSymlink("ld1", "d1", 1);
754 assertMakeFile("d1/file1", 0644, "d1/file1");
755 assertMakeFile("d1/file2", 0644, "d1/file2");
756 assertMakeSymlink("d1/link1", "file1", 0);
757 assertMakeSymlink("d1/linkX", "fileX", 0);
758 assertMakeSymlink("link2", "d1/file2", 0);
759 assertMakeSymlink("linkY", "d1/fileY", 0);
762 /* Note: this test uses archive_read_next_header()
763 instead of archive_read_next_header2() */
764 assert((a = archive_read_disk_new()) != NULL);
765 assertEqualIntA(a, ARCHIVE_OK,
766 archive_read_disk_set_symlink_logical(a));
769 * Specified file is a symbolic link file.
771 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open(a, "l/ld1"));
774 while (file_count--) {
775 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
776 if (strcmp(archive_entry_pathname(ae), "l/ld1") == 0) {
777 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
778 } else if (strcmp(archive_entry_pathname(ae),
779 "l/ld1/file1") == 0) {
780 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
781 assertEqualInt(archive_entry_size(ae), 8);
782 assertEqualIntA(a, ARCHIVE_OK,
783 archive_read_data_block(a, &p, &size, &offset));
784 assertEqualInt((int)size, 8);
785 assertEqualInt((int)offset, 0);
786 assertEqualMem(p, "d1/file1", 8);
787 assertEqualInt(ARCHIVE_EOF,
788 archive_read_data_block(a, &p, &size, &offset));
789 assertEqualInt((int)size, 0);
790 assertEqualInt((int)offset, 8);
791 } else if (strcmp(archive_entry_pathname(ae),
792 "l/ld1/file2") == 0) {
793 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
794 assertEqualInt(archive_entry_size(ae), 8);
795 assertEqualIntA(a, ARCHIVE_OK,
796 archive_read_data_block(a, &p, &size, &offset));
797 assertEqualInt((int)size, 8);
798 assertEqualInt((int)offset, 0);
799 assertEqualMem(p, "d1/file2", 8);
800 assertEqualInt(ARCHIVE_EOF,
801 archive_read_data_block(a, &p, &size, &offset));
802 assertEqualInt((int)size, 0);
803 assertEqualInt((int)offset, 8);
804 } else if (strcmp(archive_entry_pathname(ae),
805 "l/ld1/link1") == 0) {
806 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
807 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
808 assertEqualInt(archive_entry_size(ae), 8);
809 assertEqualIntA(a, ARCHIVE_OK,
810 archive_read_data_block(a, &p, &size, &offset));
811 assertEqualInt((int)size, 8);
812 assertEqualInt((int)offset, 0);
813 assertEqualMem(p, "d1/file1", 8);
814 assertEqualInt(ARCHIVE_EOF,
815 archive_read_data_block(a, &p, &size, &offset));
816 assertEqualInt((int)size, 0);
817 assertEqualInt((int)offset, 8);
818 } else if (strcmp(archive_entry_pathname(ae),
819 "l/ld1/linkX") == 0) {
820 assertEqualInt(archive_entry_filetype(ae), AE_IFLNK);
822 if (archive_entry_filetype(ae) == AE_IFDIR) {
823 /* Descend into the current object */
824 assertEqualIntA(a, ARCHIVE_OK,
825 archive_read_disk_descend(a));
828 /* There is no entry. */
829 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
830 /* Close the disk object. */
831 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
834 * Specified file is a directory and it has symbolic files.
836 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open(a, "l"));
839 while (file_count--) {
840 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
841 if (strcmp(archive_entry_pathname(ae), "l") == 0) {
842 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
843 } else if (strcmp(archive_entry_pathname(ae), "l/d1") == 0) {
844 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
845 } else if (strcmp(archive_entry_pathname(ae),
846 "l/d1/file1") == 0) {
847 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
848 assertEqualInt(archive_entry_size(ae), 8);
849 assertEqualIntA(a, ARCHIVE_OK,
850 archive_read_data_block(a, &p, &size, &offset));
851 assertEqualInt((int)size, 8);
852 assertEqualInt((int)offset, 0);
853 assertEqualMem(p, "d1/file1", 8);
854 assertEqualInt(ARCHIVE_EOF,
855 archive_read_data_block(a, &p, &size, &offset));
856 assertEqualInt((int)size, 0);
857 assertEqualInt((int)offset, 8);
858 } else if (strcmp(archive_entry_pathname(ae),
859 "l/d1/file2") == 0) {
860 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
861 assertEqualInt(archive_entry_size(ae), 8);
862 assertEqualIntA(a, ARCHIVE_OK,
863 archive_read_data_block(a, &p, &size, &offset));
864 assertEqualInt((int)size, 8);
865 assertEqualInt((int)offset, 0);
866 assertEqualMem(p, "d1/file2", 8);
867 assertEqualInt(ARCHIVE_EOF,
868 archive_read_data_block(a, &p, &size, &offset));
869 assertEqualInt((int)size, 0);
870 assertEqualInt((int)offset, 8);
871 } else if (strcmp(archive_entry_pathname(ae),
872 "l/d1/link1") == 0) {
873 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
874 assertEqualInt(archive_entry_size(ae), 8);
875 assertEqualIntA(a, ARCHIVE_OK,
876 archive_read_data_block(a, &p, &size, &offset));
877 assertEqualInt((int)size, 8);
878 assertEqualInt((int)offset, 0);
879 assertEqualMem(p, "d1/file1", 8);
880 assertEqualInt(ARCHIVE_EOF,
881 archive_read_data_block(a, &p, &size, &offset));
882 assertEqualInt((int)size, 0);
883 assertEqualInt((int)offset, 8);
884 } else if (strcmp(archive_entry_pathname(ae),
885 "l/d1/linkX") == 0) {
886 assertEqualInt(archive_entry_filetype(ae), AE_IFLNK);
887 } else if (strcmp(archive_entry_pathname(ae), "l/ld1") == 0) {
888 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
889 } else if (strcmp(archive_entry_pathname(ae),
890 "l/ld1/file1") == 0) {
891 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
892 assertEqualInt(archive_entry_size(ae), 8);
893 assertEqualIntA(a, ARCHIVE_OK,
894 archive_read_data_block(a, &p, &size, &offset));
895 assertEqualInt((int)size, 8);
896 assertEqualInt((int)offset, 0);
897 assertEqualMem(p, "d1/file1", 8);
898 assertEqualInt(ARCHIVE_EOF,
899 archive_read_data_block(a, &p, &size, &offset));
900 assertEqualInt((int)size, 0);
901 assertEqualInt((int)offset, 8);
902 } else if (strcmp(archive_entry_pathname(ae),
903 "l/ld1/file2") == 0) {
904 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
905 assertEqualInt(archive_entry_size(ae), 8);
906 assertEqualIntA(a, ARCHIVE_OK,
907 archive_read_data_block(a, &p, &size, &offset));
908 assertEqualInt((int)size, 8);
909 assertEqualInt((int)offset, 0);
910 assertEqualMem(p, "d1/file2", 8);
911 assertEqualInt(ARCHIVE_EOF,
912 archive_read_data_block(a, &p, &size, &offset));
913 assertEqualInt((int)size, 0);
914 assertEqualInt((int)offset, 8);
915 } else if (strcmp(archive_entry_pathname(ae),
916 "l/ld1/link1") == 0) {
917 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
918 assertEqualInt(archive_entry_size(ae), 8);
919 assertEqualIntA(a, ARCHIVE_OK,
920 archive_read_data_block(a, &p, &size, &offset));
921 assertEqualInt((int)size, 8);
922 assertEqualInt((int)offset, 0);
923 assertEqualMem(p, "d1/file1", 8);
924 assertEqualInt(ARCHIVE_EOF,
925 archive_read_data_block(a, &p, &size, &offset));
926 assertEqualInt((int)size, 0);
927 assertEqualInt((int)offset, 8);
928 } else if (strcmp(archive_entry_pathname(ae),
929 "l/ld1/linkX") == 0) {
930 assertEqualInt(archive_entry_filetype(ae), AE_IFLNK);
931 } else if (strcmp(archive_entry_pathname(ae),
933 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
934 assertEqualInt(archive_entry_size(ae), 8);
935 assertEqualIntA(a, ARCHIVE_OK,
936 archive_read_data_block(a, &p, &size, &offset));
937 assertEqualInt((int)size, 8);
938 assertEqualInt((int)offset, 0);
939 assertEqualMem(p, "d1/file2", 8);
940 assertEqualInt(ARCHIVE_EOF,
941 archive_read_data_block(a, &p, &size, &offset));
942 assertEqualInt((int)size, 0);
943 assertEqualInt((int)offset, 8);
944 } else if (strcmp(archive_entry_pathname(ae),
946 assertEqualInt(archive_entry_filetype(ae), AE_IFLNK);
948 if (archive_entry_filetype(ae) == AE_IFDIR) {
949 /* Descend into the current object */
950 assertEqualIntA(a, ARCHIVE_OK,
951 archive_read_disk_descend(a));
954 /* There is no entry. */
955 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
956 /* Close the disk object. */
957 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
958 /* Destroy the disk object. */
959 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
963 test_symlink_logical_loop(void)
966 struct archive_entry *ae;
973 skipping("Can't test symlinks on this filesystem");
978 * Create a sample archive.
980 assertMakeDir("l2", 0755);
982 assertMakeDir("d1", 0755);
983 assertMakeDir("d1/d2", 0755);
984 assertMakeDir("d1/d2/d3", 0755);
985 assertMakeDir("d2", 0755);
986 assertMakeFile("d2/file1", 0644, "d2/file1");
987 assertMakeSymlink("d1/d2/ld1", "../../d1", 1);
988 assertMakeSymlink("d1/d2/ld2", "../../d2", 1);
991 assert((ae = archive_entry_new()) != NULL);
992 assert((a = archive_read_disk_new()) != NULL);
993 assertEqualIntA(a, ARCHIVE_OK,
994 archive_read_disk_set_symlink_logical(a));
997 * Specified file is a symbolic link file.
999 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open(a, "l2/d1"));
1002 while (file_count--) {
1003 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header2(a, ae));
1004 if (strcmp(archive_entry_pathname(ae), "l2/d1") == 0) {
1005 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
1006 } else if (strcmp(archive_entry_pathname(ae), "l2/d1/d2") == 0) {
1007 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
1008 } else if (strcmp(archive_entry_pathname(ae), "l2/d1/d2/d3") == 0) {
1009 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
1010 } else if (strcmp(archive_entry_pathname(ae), "l2/d1/d2/ld1") == 0) {
1011 assertEqualInt(archive_entry_filetype(ae), AE_IFLNK);
1012 } else if (strcmp(archive_entry_pathname(ae), "l2/d1/d2/ld2") == 0) {
1013 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
1014 } else if (strcmp(archive_entry_pathname(ae),
1015 "l2/d1/d2/ld2/file1") == 0) {
1016 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
1017 assertEqualInt(archive_entry_size(ae), 8);
1018 assertEqualIntA(a, ARCHIVE_OK,
1019 archive_read_data_block(a, &p, &size, &offset));
1020 assertEqualInt((int)size, 8);
1021 assertEqualInt((int)offset, 0);
1022 assertEqualMem(p, "d2/file1", 8);
1023 assertEqualInt(ARCHIVE_EOF,
1024 archive_read_data_block(a, &p, &size, &offset));
1025 assertEqualInt((int)size, 0);
1026 assertEqualInt((int)offset, 8);
1028 if (archive_entry_filetype(ae) == AE_IFDIR) {
1029 /* Descend into the current object */
1030 assertEqualIntA(a, ARCHIVE_OK,
1031 archive_read_disk_descend(a));
1034 /* There is no entry. */
1035 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header2(a, ae));
1036 /* Destroy the disk object. */
1037 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1038 archive_entry_free(ae);
1042 test_restore_atime(void)
1045 struct archive_entry *ae;
1051 if (!atimeIsUpdated()) {
1052 skipping("Can't test restoring atime on this filesystem");
1056 assertMakeDir("at", 0755);
1057 assertMakeFile("at/f1", 0644, "0123456789");
1058 assertMakeFile("at/f2", 0644, "hello world");
1059 assertMakeFile("at/fe", 0644, NULL);
1060 assertUtimes("at/f1", 886600, 0, 886600, 0);
1061 assertUtimes("at/f2", 886611, 0, 886611, 0);
1062 assertUtimes("at/fe", 886611, 0, 886611, 0);
1063 assertUtimes("at", 886622, 0, 886622, 0);
1066 assert((ae = archive_entry_new()) != NULL);
1067 assert((a = archive_read_disk_new()) != NULL);
1070 * Test1: Traversals without archive_read_disk_set_atime_restored().
1072 failure("Directory traversals should work as well");
1073 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open(a, "at"));
1074 while (file_count--) {
1075 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header2(a, ae));
1076 if (strcmp(archive_entry_pathname(ae), "at") == 0) {
1077 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
1078 } else if (strcmp(archive_entry_pathname(ae), "at/f1") == 0) {
1079 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
1080 assertEqualInt(archive_entry_size(ae), 10);
1081 assertEqualIntA(a, ARCHIVE_OK,
1082 archive_read_data_block(a, &p, &size, &offset));
1083 assertEqualInt((int)size, 10);
1084 assertEqualInt((int)offset, 0);
1085 assertEqualMem(p, "0123456789", 10);
1086 assertEqualInt(ARCHIVE_EOF,
1087 archive_read_data_block(a, &p, &size, &offset));
1088 assertEqualInt((int)size, 0);
1089 assertEqualInt((int)offset, 10);
1090 } else if (strcmp(archive_entry_pathname(ae), "at/f2") == 0) {
1091 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
1092 assertEqualInt(archive_entry_size(ae), 11);
1093 assertEqualIntA(a, ARCHIVE_OK,
1094 archive_read_data_block(a, &p, &size, &offset));
1095 assertEqualInt((int)size, 11);
1096 assertEqualInt((int)offset, 0);
1097 assertEqualMem(p, "hello world", 11);
1098 assertEqualInt(ARCHIVE_EOF,
1099 archive_read_data_block(a, &p, &size, &offset));
1100 assertEqualInt((int)size, 0);
1101 assertEqualInt((int)offset, 11);
1102 } else if (strcmp(archive_entry_pathname(ae), "at/fe") == 0) {
1103 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
1104 assertEqualInt(archive_entry_size(ae), 0);
1106 if (archive_entry_filetype(ae) == AE_IFDIR) {
1107 /* Descend into the current object */
1108 assertEqualIntA(a, ARCHIVE_OK,
1109 archive_read_disk_descend(a));
1112 /* There is no entry. */
1113 failure("There must be no entry");
1114 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header2(a, ae));
1116 /* On FreeBSD (and likely other systems), atime on
1117 dirs does not change when it is read. */
1118 /* failure("Atime should be restored"); */
1119 /* assertFileAtimeRecent("at"); */
1120 failure("Atime should be restored");
1121 assertFileAtimeRecent("at/f1");
1122 failure("Atime should be restored");
1123 assertFileAtimeRecent("at/f2");
1124 failure("The atime of a empty file should not be changed");
1125 assertFileAtime("at/fe", 886611, 0);
1127 /* Close the disk object. */
1128 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
1131 * Test2: Traversals with archive_read_disk_set_atime_restored().
1133 assertUtimes("at/f1", 886600, 0, 886600, 0);
1134 assertUtimes("at/f2", 886611, 0, 886611, 0);
1135 assertUtimes("at/fe", 886611, 0, 886611, 0);
1136 assertUtimes("at", 886622, 0, 886622, 0);
1138 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_set_atime_restored(a));
1139 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open(a, "at"));
1141 failure("Directory traversals should work as well");
1142 while (file_count--) {
1143 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header2(a, ae));
1144 if (strcmp(archive_entry_pathname(ae), "at") == 0) {
1145 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
1146 } else if (strcmp(archive_entry_pathname(ae), "at/f1") == 0) {
1147 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
1148 assertEqualInt(archive_entry_size(ae), 10);
1149 assertEqualIntA(a, ARCHIVE_OK,
1150 archive_read_data_block(a, &p, &size, &offset));
1151 assertEqualInt((int)size, 10);
1152 assertEqualInt((int)offset, 0);
1153 assertEqualMem(p, "0123456789", 10);
1154 assertEqualInt(ARCHIVE_EOF,
1155 archive_read_data_block(a, &p, &size, &offset));
1156 assertEqualInt((int)size, 0);
1157 assertEqualInt((int)offset, 10);
1158 } else if (strcmp(archive_entry_pathname(ae), "at/f2") == 0) {
1159 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
1160 assertEqualInt(archive_entry_size(ae), 11);
1161 assertEqualIntA(a, ARCHIVE_OK,
1162 archive_read_data_block(a, &p, &size, &offset));
1163 assertEqualInt((int)size, 11);
1164 assertEqualInt((int)offset, 0);
1165 assertEqualMem(p, "hello world", 11);
1166 assertEqualInt(ARCHIVE_EOF,
1167 archive_read_data_block(a, &p, &size, &offset));
1168 assertEqualInt((int)size, 0);
1169 assertEqualInt((int)offset, 11);
1170 } else if (strcmp(archive_entry_pathname(ae), "at/fe") == 0) {
1171 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
1172 assertEqualInt(archive_entry_size(ae), 0);
1174 if (archive_entry_filetype(ae) == AE_IFDIR) {
1175 /* Descend into the current object */
1176 assertEqualIntA(a, ARCHIVE_OK,
1177 archive_read_disk_descend(a));
1180 /* There is no entry. */
1181 failure("There must be no entry");
1182 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header2(a, ae));
1184 failure("Atime should be restored");
1185 assertFileAtime("at", 886622, 0);
1186 failure("Atime should be restored");
1187 assertFileAtime("at/f1", 886600, 0);
1188 failure("Atime should be restored");
1189 assertFileAtime("at/f2", 886611, 0);
1190 failure("The atime of a empty file should not be changed");
1191 assertFileAtime("at/fe", 886611, 0);
1193 /* Close the disk object. */
1194 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
1197 * Test3: Traversals with archive_read_disk_set_atime_restored() but
1198 * no data read as a listing.
1200 assertUtimes("at/f1", 886600, 0, 886600, 0);
1201 assertUtimes("at/f2", 886611, 0, 886611, 0);
1202 assertUtimes("at/fe", 886611, 0, 886611, 0);
1203 assertUtimes("at", 886622, 0, 886622, 0);
1205 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_set_atime_restored(a));
1206 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open(a, "at"));
1208 failure("Directory traversals should work as well");
1209 while (file_count--) {
1210 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header2(a, ae));
1211 if (strcmp(archive_entry_pathname(ae), "at") == 0) {
1212 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
1213 } else if (strcmp(archive_entry_pathname(ae), "at/f1") == 0) {
1214 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
1215 assertEqualInt(archive_entry_size(ae), 10);
1216 } else if (strcmp(archive_entry_pathname(ae), "at/f2") == 0) {
1217 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
1218 assertEqualInt(archive_entry_size(ae), 11);
1219 } else if (strcmp(archive_entry_pathname(ae), "at/fe") == 0) {
1220 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
1221 assertEqualInt(archive_entry_size(ae), 0);
1223 if (archive_entry_filetype(ae) == AE_IFDIR) {
1224 /* Descend into the current object */
1225 assertEqualIntA(a, ARCHIVE_OK,
1226 archive_read_disk_descend(a));
1229 /* There is no entry. */
1230 failure("There must be no entry");
1231 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header2(a, ae));
1233 failure("Atime should be restored");
1234 assertFileAtime("at", 886622, 0);
1235 failure("Atime should be restored");
1236 assertFileAtime("at/f1", 886600, 0);
1237 failure("Atime should be restored");
1238 assertFileAtime("at/f2", 886611, 0);
1239 failure("The atime of a empty file should not be changed");
1240 assertFileAtime("at/fe", 886611, 0);
1243 /* Destroy the disk object. */
1244 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1245 archive_entry_free(ae);
1246 skipping("Can't test atime with nodump on this filesystem");
1250 /* Close the disk object. */
1251 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
1254 * Test4: Traversals with ARCHIVE_READDISK_RESTORE_ATIME and
1255 * ARCHIVE_READDISK_HONOR_NODUMP
1257 assertSetNodump("at/f1");
1258 assertSetNodump("at/f2");
1259 assertUtimes("at/f1", 886600, 0, 886600, 0);
1260 assertUtimes("at/f2", 886611, 0, 886611, 0);
1261 assertUtimes("at/fe", 886611, 0, 886611, 0);
1262 assertUtimes("at", 886622, 0, 886622, 0);
1264 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_set_behavior(a,
1265 ARCHIVE_READDISK_RESTORE_ATIME | ARCHIVE_READDISK_HONOR_NODUMP));
1266 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open(a, "at"));
1268 failure("Directory traversals should work as well");
1269 while (file_count--) {
1270 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header2(a, ae));
1271 if (strcmp(archive_entry_pathname(ae), "at") == 0) {
1272 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
1273 } else if (strcmp(archive_entry_pathname(ae), "at/fe") == 0) {
1274 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
1275 assertEqualInt(archive_entry_size(ae), 0);
1277 if (archive_entry_filetype(ae) == AE_IFDIR) {
1278 /* Descend into the current object */
1279 assertEqualIntA(a, ARCHIVE_OK,
1280 archive_read_disk_descend(a));
1283 /* There is no entry. */
1284 failure("There must be no entry");
1285 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header2(a, ae));
1287 failure("Atime should be restored");
1288 assertFileAtime("at", 886622, 0);
1289 failure("Atime should be restored");
1290 assertFileAtime("at/f1", 886600, 0);
1291 failure("Atime should be restored");
1292 assertFileAtime("at/f2", 886611, 0);
1293 failure("The atime of a empty file should not be changed");
1294 assertFileAtime("at/fe", 886611, 0);
1296 /* Destroy the disk object. */
1297 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1298 archive_entry_free(ae);
1302 metadata_filter(struct archive *a, void *data, struct archive_entry *ae)
1304 (void)data; /* UNUSED */
1306 failure("CTime should be set");
1307 assertEqualInt(8, archive_entry_ctime_is_set(ae));
1308 failure("MTime should be set");
1309 assertEqualInt(16, archive_entry_mtime_is_set(ae));
1311 if (archive_entry_mtime(ae) < 886611)
1313 if (archive_read_disk_can_descend(a)) {
1314 /* Descend into the current object */
1315 failure("archive_read_disk_can_descend should work"
1316 " in metadata filter");
1317 assertEqualIntA(a, 1, archive_read_disk_can_descend(a));
1318 failure("archive_read_disk_descend should work"
1319 " in metadata filter");
1320 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_descend(a));
1326 test_callbacks(void)
1330 struct archive_entry *ae;
1336 assertMakeDir("cb", 0755);
1337 assertMakeFile("cb/f1", 0644, "0123456789");
1338 assertMakeFile("cb/f2", 0644, "hello world");
1339 assertMakeFile("cb/fe", 0644, NULL);
1340 assertUtimes("cb/f1", 886600, 0, 886600, 0);
1341 assertUtimes("cb/f2", 886611, 0, 886611, 0);
1342 assertUtimes("cb/fe", 886611, 0, 886611, 0);
1343 assertUtimes("cb", 886622, 0, 886622, 0);
1345 assert((ae = archive_entry_new()) != NULL);
1346 assert((a = archive_read_disk_new()) != NULL);
1348 archive_entry_free(ae);
1351 assert((m = archive_match_new()) != NULL);
1353 archive_entry_free(ae);
1354 archive_read_free(a);
1355 archive_match_free(m);
1360 * Test1: Traversals with a name filter.
1363 assertEqualIntA(m, ARCHIVE_OK,
1364 archive_match_exclude_pattern(m, "cb/f2"));
1365 assertEqualIntA(a, ARCHIVE_OK,
1366 archive_read_disk_set_matching(a, m, NULL, NULL));
1367 failure("Directory traversals should work as well");
1368 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open(a, "cb"));
1369 while (file_count--) {
1370 archive_entry_clear(ae);
1371 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header2(a, ae));
1372 failure("File 'cb/f2' should be exclueded");
1373 assert(strcmp(archive_entry_pathname(ae), "cb/f2") != 0);
1374 if (strcmp(archive_entry_pathname(ae), "cb") == 0) {
1375 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
1376 } else if (strcmp(archive_entry_pathname(ae), "cb/f1") == 0) {
1377 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
1378 assertEqualInt(archive_entry_size(ae), 10);
1379 assertEqualIntA(a, ARCHIVE_OK,
1380 archive_read_data_block(a, &p, &size, &offset));
1381 assertEqualInt((int)size, 10);
1382 assertEqualInt((int)offset, 0);
1383 assertEqualMem(p, "0123456789", 10);
1384 assertEqualInt(ARCHIVE_EOF,
1385 archive_read_data_block(a, &p, &size, &offset));
1386 assertEqualInt((int)size, 0);
1387 assertEqualInt((int)offset, 10);
1388 } else if (strcmp(archive_entry_pathname(ae), "cb/fe") == 0) {
1389 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
1390 assertEqualInt(archive_entry_size(ae), 0);
1392 if (archive_read_disk_can_descend(a)) {
1393 /* Descend into the current object */
1394 assertEqualIntA(a, ARCHIVE_OK,
1395 archive_read_disk_descend(a));
1398 /* There is no entry. */
1399 failure("There should be no entry");
1400 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header2(a, ae));
1402 /* Close the disk object. */
1403 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
1405 /* Reset name filter */
1406 assertEqualIntA(a, ARCHIVE_OK,
1407 archive_read_disk_set_matching(a, NULL, NULL, NULL));
1410 * Test2: Traversals with a metadata filter.
1412 assertUtimes("cb/f1", 886600, 0, 886600, 0);
1413 assertUtimes("cb/f2", 886611, 0, 886611, 0);
1414 assertUtimes("cb/fe", 886611, 0, 886611, 0);
1415 assertUtimes("cb", 886622, 0, 886622, 0);
1417 assertEqualIntA(a, ARCHIVE_OK,
1418 archive_read_disk_set_metadata_filter_callback(a, metadata_filter,
1420 failure("Directory traversals should work as well");
1421 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open(a, "cb"));
1423 while (file_count--) {
1424 archive_entry_clear(ae);
1425 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header2(a, ae));
1426 failure("File 'cb/f1' should be excluded");
1427 assert(strcmp(archive_entry_pathname(ae), "cb/f1") != 0);
1428 if (strcmp(archive_entry_pathname(ae), "cb") == 0) {
1429 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
1430 } else if (strcmp(archive_entry_pathname(ae), "cb/f2") == 0) {
1431 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
1432 assertEqualInt(archive_entry_size(ae), 11);
1433 assertEqualIntA(a, ARCHIVE_OK,
1434 archive_read_data_block(a, &p, &size, &offset));
1435 assertEqualInt((int)size, 11);
1436 assertEqualInt((int)offset, 0);
1437 assertEqualMem(p, "hello world", 11);
1438 assertEqualInt(ARCHIVE_EOF,
1439 archive_read_data_block(a, &p, &size, &offset));
1440 assertEqualInt((int)size, 0);
1441 assertEqualInt((int)offset, 11);
1442 } else if (strcmp(archive_entry_pathname(ae), "cb/fe") == 0) {
1443 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
1444 assertEqualInt(archive_entry_size(ae), 0);
1447 /* There is no entry. */
1448 failure("There should be no entry");
1449 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header2(a, ae));
1451 /* Destroy the disk object. */
1452 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1453 assertEqualInt(ARCHIVE_OK, archive_match_free(m));
1454 archive_entry_free(ae);
1461 struct archive_entry *ae;
1468 skipping("Can't test nodump on this filesystem");
1472 assertMakeDir("nd", 0755);
1473 assertMakeFile("nd/f1", 0644, "0123456789");
1474 assertMakeFile("nd/f2", 0644, "hello world");
1475 assertMakeFile("nd/fe", 0644, NULL);
1476 assertSetNodump("nd/f2");
1477 assertUtimes("nd/f1", 886600, 0, 886600, 0);
1478 assertUtimes("nd/f2", 886611, 0, 886611, 0);
1479 assertUtimes("nd/fe", 886611, 0, 886611, 0);
1480 assertUtimes("nd", 886622, 0, 886622, 0);
1482 assert((ae = archive_entry_new()) != NULL);
1483 assert((a = archive_read_disk_new()) != NULL);
1486 * Test1: Traversals without ARCHIVE_READDISK_HONOR_NODUMP
1488 failure("Directory traversals should work as well");
1489 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open(a, "nd"));
1492 while (file_count--) {
1493 archive_entry_clear(ae);
1494 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header2(a, ae));
1495 if (strcmp(archive_entry_pathname(ae), "nd") == 0) {
1496 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
1497 } else if (strcmp(archive_entry_pathname(ae), "nd/f1") == 0) {
1498 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
1499 assertEqualInt(archive_entry_size(ae), 10);
1500 assertEqualIntA(a, ARCHIVE_OK,
1501 archive_read_data_block(a, &p, &size, &offset));
1502 assertEqualInt((int)size, 10);
1503 assertEqualInt((int)offset, 0);
1504 assertEqualMem(p, "0123456789", 10);
1505 assertEqualInt(ARCHIVE_EOF,
1506 archive_read_data_block(a, &p, &size, &offset));
1507 assertEqualInt((int)size, 0);
1508 assertEqualInt((int)offset, 10);
1509 } else if (strcmp(archive_entry_pathname(ae), "nd/f2") == 0) {
1510 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
1511 assertEqualInt(archive_entry_size(ae), 11);
1512 assertEqualIntA(a, ARCHIVE_OK,
1513 archive_read_data_block(a, &p, &size, &offset));
1514 assertEqualInt((int)size, 11);
1515 assertEqualInt((int)offset, 0);
1516 assertEqualMem(p, "hello world", 11);
1517 assertEqualInt(ARCHIVE_EOF,
1518 archive_read_data_block(a, &p, &size, &offset));
1519 assertEqualInt((int)size, 0);
1520 assertEqualInt((int)offset, 11);
1521 } else if (strcmp(archive_entry_pathname(ae), "nd/fe") == 0) {
1522 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
1523 assertEqualInt(archive_entry_size(ae), 0);
1525 if (archive_read_disk_can_descend(a)) {
1526 /* Descend into the current object */
1527 assertEqualIntA(a, ARCHIVE_OK,
1528 archive_read_disk_descend(a));
1531 /* There is no entry. */
1532 failure("There should be no entry");
1533 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header2(a, ae));
1535 /* Close the disk object. */
1536 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
1539 * Test2: Traversals with ARCHIVE_READDISK_HONOR_NODUMP
1541 assertUtimes("nd/f1", 886600, 0, 886600, 0);
1542 assertUtimes("nd/f2", 886611, 0, 886611, 0);
1543 assertUtimes("nd/fe", 886611, 0, 886611, 0);
1544 assertUtimes("nd", 886622, 0, 886622, 0);
1546 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_set_behavior(a,
1547 ARCHIVE_READDISK_RESTORE_ATIME | ARCHIVE_READDISK_HONOR_NODUMP));
1548 failure("Directory traversals should work as well");
1549 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open(a, "nd"));
1552 while (file_count--) {
1553 archive_entry_clear(ae);
1554 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header2(a, ae));
1555 failure("File 'nd/f2' should be exclueded");
1556 assert(strcmp(archive_entry_pathname(ae), "nd/f2") != 0);
1557 if (strcmp(archive_entry_pathname(ae), "nd") == 0) {
1558 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
1559 } else if (strcmp(archive_entry_pathname(ae), "nd/f1") == 0) {
1560 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
1561 assertEqualInt(archive_entry_size(ae), 10);
1562 assertEqualIntA(a, ARCHIVE_OK,
1563 archive_read_data_block(a, &p, &size, &offset));
1564 assertEqualInt((int)size, 10);
1565 assertEqualInt((int)offset, 0);
1566 assertEqualMem(p, "0123456789", 10);
1567 assertEqualInt(ARCHIVE_EOF,
1568 archive_read_data_block(a, &p, &size, &offset));
1569 assertEqualInt((int)size, 0);
1570 assertEqualInt((int)offset, 10);
1571 } else if (strcmp(archive_entry_pathname(ae), "nd/fe") == 0) {
1572 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
1573 assertEqualInt(archive_entry_size(ae), 0);
1575 if (archive_read_disk_can_descend(a)) {
1576 /* Descend into the current object */
1577 assertEqualIntA(a, ARCHIVE_OK,
1578 archive_read_disk_descend(a));
1581 /* There is no entry. */
1582 failure("There should be no entry");
1583 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header2(a, ae));
1585 failure("Atime should be restored");
1586 assertFileAtime("nd/f2", 886611, 0);
1588 /* Destroy the disk object. */
1589 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1590 archive_entry_free(ae);
1597 struct archive_entry *ae;
1605 assertMakeDir("lock", 0311);
1606 assertMakeDir("lock/dir1", 0755);
1607 assertMakeFile("lock/dir1/f1", 0644, "0123456789");
1608 assertMakeDir("lock/lock2", 0311);
1609 assertMakeDir("lock/lock2/dir1", 0755);
1610 assertMakeFile("lock/lock2/dir1/f1", 0644, "0123456789");
1612 assert((ae = archive_entry_new()) != NULL);
1613 assert((a = archive_read_disk_new()) != NULL);
1616 * Test1: Traverse lock/dir1 as .
1618 assertChdir("lock/dir1");
1620 failure("Directory traversals should work as well");
1621 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open(a, "."));
1625 while (file_count--) {
1626 archive_entry_clear(ae);
1627 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header2(a, ae));
1628 if (strcmp(archive_entry_pathname(ae), ".") == 0) {
1629 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
1631 } else if (strcmp(archive_entry_pathname(ae), "./f1") == 0) {
1632 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
1633 assertEqualInt(archive_entry_size(ae), 10);
1634 assertEqualIntA(a, ARCHIVE_OK,
1635 archive_read_data_block(a, &p, &size, &offset));
1636 assertEqualInt((int)size, 10);
1637 assertEqualInt((int)offset, 0);
1638 assertEqualMem(p, "0123456789", 10);
1639 assertEqualInt(ARCHIVE_EOF,
1640 archive_read_data_block(a, &p, &size, &offset));
1641 assertEqualInt((int)size, 0);
1642 assertEqualInt((int)offset, 10);
1645 if (archive_read_disk_can_descend(a)) {
1646 /* Descend into the current object */
1647 assertEqualIntA(a, ARCHIVE_OK,
1648 archive_read_disk_descend(a));
1651 failure("Did not match expected filenames");
1652 assertEqualInt(match_count, 2);
1654 * There is no entry. This will however fail if the directory traverse
1655 * tries to ascend past the initial directory, since it lacks permission
1658 failure("There should be no entry and no error");
1659 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header2(a, ae));
1661 /* Close the disk object. */
1662 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
1664 assertChdir("../..");
1667 * Test2: Traverse lock/dir1 directly
1669 failure("Directory traversals should work as well");
1670 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open(a, "lock/dir1"));
1674 while (file_count--) {
1675 archive_entry_clear(ae);
1676 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header2(a, ae));
1677 if (strcmp(archive_entry_pathname(ae), "lock/dir1") == 0) {
1678 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
1680 } else if (strcmp(archive_entry_pathname(ae), "lock/dir1/f1") == 0) {
1681 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
1682 assertEqualInt(archive_entry_size(ae), 10);
1683 assertEqualIntA(a, ARCHIVE_OK,
1684 archive_read_data_block(a, &p, &size, &offset));
1685 assertEqualInt((int)size, 10);
1686 assertEqualInt((int)offset, 0);
1687 assertEqualMem(p, "0123456789", 10);
1688 assertEqualInt(ARCHIVE_EOF,
1689 archive_read_data_block(a, &p, &size, &offset));
1690 assertEqualInt((int)size, 0);
1691 assertEqualInt((int)offset, 10);
1694 if (archive_read_disk_can_descend(a)) {
1695 /* Descend into the current object */
1696 assertEqualIntA(a, ARCHIVE_OK,
1697 archive_read_disk_descend(a));
1700 failure("Did not match expected filenames");
1701 assertEqualInt(match_count, 2);
1703 * There is no entry. This will however fail if the directory traverse
1704 * tries to ascend past the initial directory, since it lacks permission
1707 failure("There should be no entry and no error");
1708 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header2(a, ae));
1710 /* Close the disk object. */
1711 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
1714 * Test3: Traverse lock/dir1/.
1716 failure("Directory traversals should work as well");
1717 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open(a, "lock/dir1/."));
1721 while (file_count--) {
1722 archive_entry_clear(ae);
1723 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header2(a, ae));
1724 if (strcmp(archive_entry_pathname(ae), "lock/dir1/.") == 0) {
1725 assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
1727 } else if (strcmp(archive_entry_pathname(ae), "lock/dir1/./f1") == 0) {
1728 assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
1729 assertEqualInt(archive_entry_size(ae), 10);
1730 assertEqualIntA(a, ARCHIVE_OK,
1731 archive_read_data_block(a, &p, &size, &offset));
1732 assertEqualInt((int)size, 10);
1733 assertEqualInt((int)offset, 0);
1734 assertEqualMem(p, "0123456789", 10);
1735 assertEqualInt(ARCHIVE_EOF,
1736 archive_read_data_block(a, &p, &size, &offset));
1737 assertEqualInt((int)size, 0);
1738 assertEqualInt((int)offset, 10);
1741 if (archive_read_disk_can_descend(a)) {
1742 /* Descend into the current object */
1743 assertEqualIntA(a, ARCHIVE_OK,
1744 archive_read_disk_descend(a));
1747 failure("Did not match expected filenames");
1748 assertEqualInt(match_count, 2);
1750 * There is no entry. This will however fail if the directory traverse
1751 * tries to ascend past the initial directory, since it lacks permission
1754 failure("There should be no entry and no error");
1755 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header2(a, ae));
1757 /* Close the disk object. */
1758 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
1761 * Test4: Traverse lock/lock2/dir1 from inside lock.
1763 * This test is expected to fail on platforms with no O_EXEC or
1764 * equivalent (e.g. O_PATH on Linux or O_SEARCH on SunOS), because
1765 * the current traversal code can't handle the case where it can't
1766 * obtain an open fd for the initial current directory. We need to
1767 * check that condition here, because if O_EXEC _does_ exist, we don't
1768 * want to overlook any failure.
1770 assertChdir("lock");
1772 failure("Directory traversals should work as well");
1773 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open(a, "lock2/dir1"));
1775 archive_entry_clear(ae);
1776 r = archive_read_next_header2(a, ae);
1777 if (r == ARCHIVE_FAILED) {
1778 #if defined(O_PATH) || defined(O_SEARCH) || \
1779 (defined(__FreeBSD__) && defined(O_EXEC))
1780 assertEqualIntA(a, ARCHIVE_OK, r);
1782 /* Close the disk object. */
1783 archive_read_close(a);
1787 while (file_count--) {
1788 if (file_count == 0)
1789 assertEqualIntA(a, ARCHIVE_OK,
1790 archive_read_next_header2(a, ae));
1791 if (strcmp(archive_entry_pathname(ae),
1792 "lock2/dir1") == 0) {
1793 assertEqualInt(archive_entry_filetype(ae),
1796 } else if (strcmp(archive_entry_pathname(ae),
1797 "lock2/dir1/f1") == 0) {
1798 assertEqualInt(archive_entry_filetype(ae),
1800 assertEqualInt(archive_entry_size(ae), 10);
1801 assertEqualIntA(a, ARCHIVE_OK,
1802 archive_read_data_block(a, &p, &size,
1804 assertEqualInt((int)size, 10);
1805 assertEqualInt((int)offset, 0);
1806 assertEqualMem(p, "0123456789", 10);
1807 assertEqualInt(ARCHIVE_EOF,
1808 archive_read_data_block(a, &p, &size,
1810 assertEqualInt((int)size, 0);
1811 assertEqualInt((int)offset, 10);
1814 if (archive_read_disk_can_descend(a)) {
1815 /* Descend into the current object */
1816 assertEqualIntA(a, ARCHIVE_OK,
1817 archive_read_disk_descend(a));
1820 failure("Did not match expected filenames");
1821 assertEqualInt(match_count, 2);
1823 * There is no entry. This will however fail if the directory
1824 * traverse tries to ascend past the initial directory, since
1825 * it lacks permission to do so.
1827 failure("There should be no entry and no error");
1828 assertEqualIntA(a, ARCHIVE_EOF,
1829 archive_read_next_header2(a, ae));
1831 /* Close the disk object. */
1832 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
1836 assertChmod("lock", 0755);
1837 assertChmod("lock/lock2", 0755);
1839 /* Destroy the disk object. */
1840 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1841 archive_entry_free(ae);
1844 DEFINE_TEST(test_read_disk_directory_traversals)
1848 /* Test hybrid mode; follow symlink initially, then not. */
1849 test_symlink_hybrid();
1850 /* Test logical mode; follow all symlinks. */
1851 test_symlink_logical();
1852 /* Test logical mode; prevent loop in symlinks. */
1853 test_symlink_logical_loop();
1854 /* Test to restore atime. */
1855 test_restore_atime();
1856 /* Test callbacks. */
1860 /* Test parent overshoot. */