contrib/libarchive/libarchive/test/test_read_format_mtree.c

   1 /*-
   2  * Copyright (c) 2003-2007 Tim Kientzle
   3  * Copyright (c) 2011-2012 Michihiro NAKAJIMA
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26 #include "test.h"
  27 __FBSDID("$FreeBSD$");
  28
  29 static void
  30 test_read_format_mtree1(void)
  31 {
  32         const char reffile[] = "test_read_format_mtree.mtree";
  33         char buff[16];
  34         struct archive_entry *ae;
  35         struct archive *a;
  36         FILE *f;
  37         /* Compute max 64-bit signed twos-complement value
  38          * without relying on overflow.  This assumes that long long
  39          * is at least 64 bits. */
  40         static const long long max_int64 = ((((long long)1) << 62) - 1) + (((long long)1) << 62);
  41         time_t min_time;
  42         volatile time_t t;
  43
  44         extract_reference_file(reffile);
  45
  46         /*
  47          * An access error occurred on some platform when mtree
  48          * format handling open a directory. It is for through
  49          * the routine which open a directory that we create
  50          * "dir" and "dir2" directories.
  51          */
  52         assertMakeDir("dir", 0775);
  53         assertMakeDir("dir2", 0775);
  54
  55         assert((a = archive_read_new()) != NULL);
  56         assertEqualIntA(a, ARCHIVE_OK,
  57             archive_read_support_filter_all(a));
  58         assertEqualIntA(a, ARCHIVE_OK,
  59             archive_read_support_format_all(a));
  60         assertEqualIntA(a, ARCHIVE_OK,
  61             archive_read_set_options(a, "mtree:checkfs"));
  62         assertEqualIntA(a, ARCHIVE_OK,
  63             archive_read_open_filename(a, reffile, 11));
  64
  65         /*
  66          * Read "file", whose data is available on disk.
  67          */
  68         f = fopen("file", "wb");
  69         assert(f != NULL);
  70         assertEqualInt(3, fwrite("hi\n", 1, 3, f));
  71         fclose(f);
  72         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
  73         assertEqualInt(archive_format(a), ARCHIVE_FORMAT_MTREE);
  74         assertEqualString(archive_entry_pathname(ae), "file");
  75         assertEqualInt(archive_entry_uid(ae), 18);
  76         assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
  77         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0123);
  78         assertEqualInt(archive_entry_size(ae), 3);
  79         assertEqualInt(3, archive_read_data(a, buff, 3));
  80         assertEqualMem(buff, "hi\n", 3);
  81         assertEqualInt(archive_entry_is_encrypted(ae), 0);
  82         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
  83
  84         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
  85         assertEqualString(archive_entry_pathname(ae), "dir");
  86         assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
  87         assertEqualInt(archive_entry_is_encrypted(ae), 0);
  88         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
  89
  90         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
  91         assertEqualString(archive_entry_pathname(ae), "dir/file with space");
  92         assertEqualInt(archive_entry_is_encrypted(ae), 0);
  93         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
  94
  95         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
  96         assertEqualString(archive_entry_pathname(ae), "file with space");
  97         assertEqualInt(archive_entry_is_encrypted(ae), 0);
  98         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
  99
 100         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 101         assertEqualString(archive_entry_pathname(ae), "dir2");
 102         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 103         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 104
 105         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 106         assertEqualString(archive_entry_pathname(ae), "dir2/dir3a");
 107         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 108         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 109
 110         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 111         assertEqualString(archive_entry_pathname(ae), "dir2/dir3a/indir3a");
 112         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 113         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 114
 115         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 116         assertEqualString(archive_entry_pathname(ae), "dir2/fullindir2");
 117         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0644);
 118         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 119         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 120
 121         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 122         assertEqualString(archive_entry_pathname(ae), "dir2/indir2");
 123         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 124         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 125
 126         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 127         assertEqualString(archive_entry_pathname(ae), "dir2/dir3b");
 128         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 129         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 130
 131         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 132         assertEqualString(archive_entry_pathname(ae), "dir2/dir3b/indir3b");
 133         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 134         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 135
 136         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 137         assertEqualString(archive_entry_pathname(ae), "dir2/dir3b/filename\\with_esc\b\t\fapes");
 138         assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
 139         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 140         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 141
 142         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 143         assertEqualString(archive_entry_pathname(ae), "notindir");
 144         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 145         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 146
 147         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 148         assertEqualString(archive_entry_pathname(ae), "dir2/emptyfile");
 149         assertEqualInt(archive_entry_size(ae), 0);
 150         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 151         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 152
 153         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 154         assertEqualString(archive_entry_pathname(ae), "dir2/smallfile");
 155         assertEqualInt(archive_entry_size(ae), 1);
 156         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 157         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 158
 159         /* TODO: Mtree reader should probably return ARCHIVE_WARN for this. */
 160         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 161         assertEqualString(archive_entry_pathname(ae), "dir2/toosmallfile");
 162         assertEqualInt(archive_entry_size(ae), -1);
 163         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 164         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 165
 166         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 167         assertEqualString(archive_entry_pathname(ae), "dir2/bigfile");
 168         assertEqualInt(archive_entry_size(ae), max_int64);
 169         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 170         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 171
 172         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 173         assertEqualString(archive_entry_pathname(ae), "dir2/toobigfile");
 174         /* Size in mtree is max_int64 + 1; should return max_int64. */
 175         assertEqualInt(archive_entry_size(ae), max_int64);
 176         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 177         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 178
 179         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 180         assertEqualString(archive_entry_pathname(ae), "dir2/veryoldfile");
 181         /* The value in the file is MIN_INT64_T, but time_t may be narrower. */
 182         /* Verify min_time is the smallest possible time_t. */
 183         min_time = archive_entry_mtime(ae);
 184         assert(min_time <= 0);
 185         /* Simply asserting min_time - 1 > 0 breaks with some compiler optimizations. */
 186         t = (time_t)((uintmax_t)min_time - 1);
 187         assert(t > 0);
 188         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 189         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 190
 191         /* toooldfile is 1 sec older, which should overflow and get returned
 192          * with the same value. */
 193         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 194         assertEqualString(archive_entry_pathname(ae), "dir2/toooldfile");
 195         assertEqualInt(archive_entry_mtime(ae), min_time);
 196         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 197         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 198
 199         /* md5digest */
 200         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 201         assertEqualString(archive_entry_pathname(ae), "dir2/md5file");
 202         assertEqualMem(archive_entry_digest(ae, ARCHIVE_ENTRY_DIGEST_MD5),
 203             "\xd4\x1d\x8c\xd9\x8f\x00\xb2\x04\xe9\x80\x09\x98\xec\xf8\x42\x7e",
 204             16);
 205
 206         /* rmd160digest */
 207         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 208         assertEqualString(archive_entry_pathname(ae), "dir2/rmd160file");
 209         assertEqualMem(archive_entry_digest(ae, ARCHIVE_ENTRY_DIGEST_RMD160),
 210             "\xda\x39\xa3\xee\x5e\x6b\x4b\x0d\x32\x55\xbf\xef\x95\x60\x18\x90"
 211             "\xaf\xd8\x07\x09", 20);
 212
 213         /* sha1digest */
 214         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 215         assertEqualString(archive_entry_pathname(ae), "dir2/sha1file");
 216         assertEqualMem(archive_entry_digest(ae, ARCHIVE_ENTRY_DIGEST_SHA1),
 217             "\xda\x39\xa3\xee\x5e\x6b\x4b\x0d\x32\x55\xbf\xef\x95\x60\x18\x90"
 218             "\xaf\xd8\x07\x09", 20);
 219
 220         /* sha256digest */
 221         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 222         assertEqualString(archive_entry_pathname(ae), "dir2/sha256file");
 223         assertEqualMem(archive_entry_digest(ae, ARCHIVE_ENTRY_DIGEST_SHA256),
 224             "\xe3\xb0\xc4\x42\x98\xfc\x1c\x14\x9a\xfb\xf4\xc8\x99\x6f\xb9\x24"
 225             "\x27\xae\x41\xe4\x64\x9b\x93\x4c\xa4\x95\x99\x1b\x78\x52\xb8\x55",
 226             32);
 227
 228         /* sha384digest */
 229         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 230         assertEqualString(archive_entry_pathname(ae), "dir2/sha384file");
 231         assertEqualMem(archive_entry_digest(ae, ARCHIVE_ENTRY_DIGEST_SHA384),
 232             "\x38\xb0\x60\xa7\x51\xac\x96\x38\x4c\xd9\x32\x7e\xb1\xb1\xe3\x6a"
 233             "\x21\xfd\xb7\x11\x14\xbe\x07\x43\x4c\x0c\xc7\xbf\x63\xf6\xe1\xda"
 234             "\x27\x4e\xde\xbf\xe7\x6f\x65\xfb\xd5\x1a\xd2\xf1\x48\x98\xb9\x5b",
 235             48);
 236
 237         /* sha512digest */
 238         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 239         assertEqualString(archive_entry_pathname(ae), "dir2/sha512file");
 240         assertEqualMem(archive_entry_digest(ae, ARCHIVE_ENTRY_DIGEST_SHA512),
 241             "\xcf\x83\xe1\x35\x7e\xef\xb8\xbd\xf1\x54\x28\x50\xd6\x6d\x80\x07"
 242             "\xd6\x20\xe4\x05\x0b\x57\x15\xdc\x83\xf4\xa9\x21\xd3\x6c\xe9\xce"
 243             "\x47\xd0\xd1\x3c\x5d\x85\xf2\xb0\xff\x83\x18\xd2\x87\x7e\xec\x2f"
 244             "\x63\xb9\x31\xbd\x47\x41\x7a\x81\xa5\x38\x32\x7a\xf9\x27\xda\x3e",
 245             64);
 246
 247         /* md5 digest is too short */
 248         assertEqualIntA(a, ARCHIVE_WARN, archive_read_next_header(a, &ae));
 249         assertEqualString(archive_entry_pathname(ae), "dir2/md5tooshort");
 250         assertMemoryFilledWith(archive_entry_digest(ae, ARCHIVE_ENTRY_DIGEST_MD5),
 251             16, 0x00);
 252
 253         /* md5 digest is too long */
 254         assertEqualIntA(a, ARCHIVE_WARN, archive_read_next_header(a, &ae));
 255         assertEqualString(archive_entry_pathname(ae), "dir2/md5toolong");
 256         assertMemoryFilledWith(archive_entry_digest(ae, ARCHIVE_ENTRY_DIGEST_MD5),
 257             16, 0x00);
 258
 259         /* md5 digest is uppercase hex */
 260         assertEqualIntA(a, ARCHIVE_WARN, archive_read_next_header(a, &ae));
 261         assertEqualString(archive_entry_pathname(ae), "dir2/md5caphex");
 262         assertMemoryFilledWith(archive_entry_digest(ae, ARCHIVE_ENTRY_DIGEST_MD5),
 263             16, 0x00);
 264
 265         /* md5 digest is not hex */
 266         assertEqualIntA(a, ARCHIVE_WARN, archive_read_next_header(a, &ae));
 267         assertEqualString(archive_entry_pathname(ae), "dir2/md5nothex");
 268         assertMemoryFilledWith(archive_entry_digest(ae, ARCHIVE_ENTRY_DIGEST_MD5),
 269             16, 0x00);
 270
 271         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 272         assertEqualInt(30, archive_file_count(a));
 273         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 274         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 275 }
 276
 277 static void
 278 test_read_format_mtree2(void)
 279 {
 280         static char archive[] =
 281             "#mtree\n"
 282             "d type=dir content=.\n";
 283         struct archive_entry *ae;
 284         struct archive *a;
 285
 286         assert((a = archive_read_new()) != NULL);
 287         assertEqualIntA(a, ARCHIVE_OK,
 288             archive_read_support_filter_all(a));
 289         assertEqualIntA(a, ARCHIVE_OK,
 290             archive_read_support_format_all(a));
 291         assertEqualIntA(a, ARCHIVE_OK,
 292             archive_read_set_options(a, "mtree:checkfs"));
 293         assertEqualIntA(a, ARCHIVE_OK,
 294             archive_read_open_memory(a, archive, sizeof(archive)));
 295         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 296         assertEqualInt(archive_format(a), ARCHIVE_FORMAT_MTREE);
 297         assertEqualString(archive_entry_pathname(ae), "d");
 298         assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
 299         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 300         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 301         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 302         assertEqualInt(1, archive_file_count(a));
 303         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 304         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 305 }
 306
 307 /*
 308  * Reported to libarchive.googlecode.com as Issue 121.
 309  */
 310 static void
 311 test_read_format_mtree3(void)
 312 {
 313         static char archive[] =
 314             "#mtree\n"
 315             "a type=file contents=file\n"
 316             "b type=link link=a\n"
 317             "c type=file contents=file\n";
 318         struct archive_entry *ae;
 319         struct archive *a;
 320
 321         assertMakeDir("mtree3", 0777);
 322         assertChdir("mtree3");
 323         assertMakeFile("file", 0644, "file contents");
 324
 325         assert((a = archive_read_new()) != NULL);
 326         assertEqualIntA(a, ARCHIVE_OK,
 327             archive_read_support_filter_all(a));
 328         assertEqualIntA(a, ARCHIVE_OK,
 329             archive_read_support_format_all(a));
 330         assertEqualIntA(a, ARCHIVE_OK,
 331             archive_read_set_options(a, "mtree:checkfs"));
 332         assertEqualIntA(a, ARCHIVE_OK,
 333             archive_read_open_memory(a, archive, sizeof(archive)));
 334         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 335         assertEqualString(archive_entry_pathname(ae), "a");
 336         assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
 337         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 338         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 339         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 340         assertEqualString(archive_entry_pathname(ae), "b");
 341         assertEqualInt(archive_entry_filetype(ae), AE_IFLNK);
 342         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 343         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 344         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 345         assertEqualString(archive_entry_pathname(ae), "c");
 346         assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
 347         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 348         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 349
 350         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 351         assertEqualInt(3, archive_file_count(a));
 352         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 353         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 354
 355         assertChdir("..");
 356 }
 357
 358 DEFINE_TEST(test_read_format_mtree)
 359 {
 360         test_read_format_mtree1();
 361         test_read_format_mtree2();
 362         test_read_format_mtree3();
 363 }
 364
 365 DEFINE_TEST(test_read_format_mtree_filenames_only)
 366 {
 367         static char archive[] =
 368             "/set type=file mode=0644\n"
 369             "./a\n"
 370             "./b\n"
 371             "./c\n"
 372             "./d\n"
 373             "./e\n"
 374             "./f mode=0444\n";
 375         struct archive_entry *ae;
 376         struct archive *a;
 377
 378         assertMakeFile("file", 0644, "file contents");
 379
 380         assert((a = archive_read_new()) != NULL);
 381         assertEqualIntA(a, ARCHIVE_OK,
 382             archive_read_support_filter_all(a));
 383         assertEqualIntA(a, ARCHIVE_OK,
 384             archive_read_support_format_all(a));
 385         assertEqualIntA(a, ARCHIVE_OK,
 386             archive_read_set_options(a, "mtree:checkfs"));
 387         assertEqualIntA(a, ARCHIVE_OK,
 388             archive_read_open_memory(a, archive, sizeof(archive)));
 389         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 390         assertEqualString(archive_entry_pathname(ae), "./a");
 391         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0644);
 392         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 393         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 394         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 395         assertEqualString(archive_entry_pathname(ae), "./b");
 396         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0644);
 397         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 398         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 399         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 400         assertEqualString(archive_entry_pathname(ae), "./c");
 401         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0644);
 402         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 403         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 404         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 405         assertEqualString(archive_entry_pathname(ae), "./d");
 406         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0644);
 407         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 408         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 409         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 410         assertEqualString(archive_entry_pathname(ae), "./e");
 411         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0644);
 412         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 413         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 414         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 415         assertEqualString(archive_entry_pathname(ae), "./f");
 416         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0444);
 417         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 418         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 419
 420         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 421         assertEqualInt(6, archive_file_count(a));
 422         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 423         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 424 }
 425
 426 DEFINE_TEST(test_read_format_mtree_nochange)
 427 {
 428         static char archive[] =
 429             "#mtree\n"
 430             "./a type=file mode=0644 time=123\n"
 431             "./b type=file mode=0644 time=234\n"
 432             "./c type=file mode=0644 time=345\n";
 433         static char archive2[] =
 434             "#mtree\n"
 435             "./a type=file mode=0644 time=123 nochange\n"
 436             "./b type=file mode=0644 time=234\n"
 437             "./c type=file mode=0644 time=345 nochange\n";
 438         struct archive_entry *ae;
 439         struct archive *a;
 440
 441         assertMakeFile("a", 0640, "12345");
 442         assertMakeFile("b", 0664, "123456");
 443         assertMakeFile("c", 0755, "1234567");
 444
 445         /*
 446          * Test 1. Read a mtree archive without `nochange' keyword.
 447          */
 448         assert((a = archive_read_new()) != NULL);
 449         assertEqualIntA(a, ARCHIVE_OK,
 450             archive_read_support_filter_all(a));
 451         assertEqualIntA(a, ARCHIVE_OK,
 452             archive_read_support_format_all(a));
 453         assertEqualIntA(a, ARCHIVE_OK,
 454             archive_read_set_options(a, "mtree:checkfs"));
 455         assertEqualIntA(a, ARCHIVE_OK,
 456             archive_read_open_memory(a, archive, sizeof(archive)));
 457         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 458         assertEqualString(archive_entry_pathname(ae), "./a");
 459         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0644);
 460         assertEqualInt(archive_entry_mtime(ae), 123);
 461         assertEqualInt(archive_entry_size(ae), 5);
 462         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 463         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 464         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 465         assertEqualString(archive_entry_pathname(ae), "./b");
 466         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0644);
 467         assertEqualInt(archive_entry_mtime(ae), 234);
 468         assertEqualInt(archive_entry_size(ae), 6);
 469         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 470         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 471         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 472         assertEqualString(archive_entry_pathname(ae), "./c");
 473         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0644);
 474         assertEqualInt(archive_entry_mtime(ae), 345);
 475         assertEqualInt(archive_entry_size(ae), 7);
 476         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 477         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 478
 479         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 480         assertEqualInt(3, archive_file_count(a));
 481         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 482         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 483
 484         /*
 485          * Test 2. Read a mtree archive with `nochange' keyword.
 486          */
 487         assert((a = archive_read_new()) != NULL);
 488         assertEqualIntA(a, ARCHIVE_OK,
 489             archive_read_support_filter_all(a));
 490         assertEqualIntA(a, ARCHIVE_OK,
 491             archive_read_support_format_all(a));
 492         assertEqualIntA(a, ARCHIVE_OK,
 493             archive_read_set_options(a, "mtree:checkfs"));
 494         assertEqualIntA(a, ARCHIVE_OK,
 495             archive_read_open_memory(a, archive2, sizeof(archive2)));
 496         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 497         assertEqualString(archive_entry_pathname(ae), "./a");
 498 #if !defined(_WIN32) || defined(__CYGWIN__)
 499         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0640);
 500 #endif
 501         assert(archive_entry_mtime(ae) != 123);
 502         assertEqualInt(archive_entry_size(ae), 5);
 503         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 504         assertEqualString(archive_entry_pathname(ae), "./b");
 505         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0644);
 506         assertEqualInt(archive_entry_mtime(ae), 234);
 507         assertEqualInt(archive_entry_size(ae), 6);
 508         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 509         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 510         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 511         assertEqualString(archive_entry_pathname(ae), "./c");
 512 #if !defined(_WIN32) || defined(__CYGWIN__)
 513         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0755);
 514 #endif
 515         assert(archive_entry_mtime(ae) != 345);
 516         assertEqualInt(archive_entry_size(ae), 7);
 517         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 518         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 519
 520         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 521         assertEqualInt(3, archive_file_count(a));
 522         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 523         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 524 }
 525
 526 DEFINE_TEST(test_read_format_mtree_nomagic_v1_form)
 527 {
 528         const char reffile[] = "test_read_format_mtree_nomagic.mtree";
 529         char buff[16];
 530         struct archive_entry *ae;
 531         struct archive *a;
 532         FILE *f;
 533
 534         extract_reference_file(reffile);
 535
 536         assert((a = archive_read_new()) != NULL);
 537         assertEqualIntA(a, ARCHIVE_OK,
 538             archive_read_support_filter_all(a));
 539         assertEqualIntA(a, ARCHIVE_OK,
 540             archive_read_support_format_all(a));
 541         assertEqualIntA(a, ARCHIVE_OK,
 542             archive_read_set_options(a, "mtree:checkfs"));
 543         assertEqualIntA(a, ARCHIVE_OK,
 544             archive_read_open_filename(a, reffile, 11));
 545
 546         /*
 547          * Read "file", whose data is available on disk.
 548          */
 549         f = fopen("file", "wb");
 550         assert(f != NULL);
 551         assertEqualInt(3, fwrite("hi\n", 1, 3, f));
 552         fclose(f);
 553         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 554         assertEqualInt(archive_format(a), ARCHIVE_FORMAT_MTREE);
 555         assertEqualString(archive_entry_pathname(ae), "file");
 556         assertEqualInt(archive_entry_uid(ae), 18);
 557         assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
 558         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0123);
 559         assertEqualInt(archive_entry_size(ae), 3);
 560         assertEqualInt(3, archive_read_data(a, buff, 3));
 561         assertEqualMem(buff, "hi\n", 3);
 562         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 563         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 564
 565         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 566         assertEqualString(archive_entry_pathname(ae), "dir");
 567         assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
 568         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 569         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 570
 571         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 572         assertEqualString(archive_entry_pathname(ae), "dir/file with space");
 573         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 574         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 575
 576         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 577         assertEqualString(archive_entry_pathname(ae), "file with space");
 578         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 579         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 580
 581         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 582         assertEqualString(archive_entry_pathname(ae), "dir2");
 583         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 584         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 585
 586         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 587         assertEqualString(archive_entry_pathname(ae), "dir2/dir3a");
 588         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 589         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 590
 591         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 592         assertEqualString(archive_entry_pathname(ae), "dir2/dir3a/indir3a");
 593         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 594         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 595
 596         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 597         assertEqualString(archive_entry_pathname(ae), "dir2/fullindir2");
 598         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0644);
 599         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 600         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 601
 602         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 603         assertEqualString(archive_entry_pathname(ae), "dir2/indir2");
 604         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 605         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 606
 607         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 608         assertEqualString(archive_entry_pathname(ae), "dir2/dir3b");
 609         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 610         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 611
 612         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 613         assertEqualString(archive_entry_pathname(ae), "dir2/dir3b/indir3b");
 614         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 615         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 616
 617         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 618         assertEqualString(archive_entry_pathname(ae), "notindir");
 619         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 620         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
 621
 622         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 623         assertEqualInt(12, archive_file_count(a));
 624         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 625         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 626 }
 627
 628 /*
 629  * Test for a format that NetBSD mtree -C generates.
 630  */
 631 DEFINE_TEST(test_read_format_mtree_nomagic_v2_form)
 632 {
 633         const char reffile[] = "test_read_format_mtree_nomagic2.mtree";
 634         char buff[16];
 635         struct archive_entry *ae;
 636         struct archive *a;
 637         FILE *f;
 638
 639         extract_reference_file(reffile);
 640
 641         assert((a = archive_read_new()) != NULL);
 642         assertEqualIntA(a, ARCHIVE_OK,
 643             archive_read_support_filter_all(a));
 644         assertEqualIntA(a, ARCHIVE_OK,
 645             archive_read_support_format_all(a));
 646         assertEqualIntA(a, ARCHIVE_OK,
 647             archive_read_set_options(a, "mtree:checkfs"));
 648         assertEqualIntA(a, ARCHIVE_OK,
 649             archive_read_open_filename(a, reffile, 11));
 650
 651         /*
 652          * Read "file", whose data is available on disk.
 653          */
 654         f = fopen("file", "wb");
 655         assert(f != NULL);
 656         assertEqualInt(3, fwrite("hi\n", 1, 3, f));
 657         fclose(f);
 658         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 659         assertEqualInt(archive_format(a), ARCHIVE_FORMAT_MTREE);
 660         assertEqualString(archive_entry_pathname(ae), "./file");
 661         assertEqualInt(archive_entry_uid(ae), 18);
 662         assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
 663         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0123);
 664         assertEqualInt(archive_entry_size(ae), 3);
 665         assertEqualInt(3, archive_read_data(a, buff, 3));
 666         assertEqualMem(buff, "hi\n", 3);
 667
 668         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 669         assertEqualString(archive_entry_pathname(ae), "./dir");
 670         assertEqualInt(archive_entry_mode(ae), AE_IFDIR | 0755);
 671
 672         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 673         assertEqualString(archive_entry_pathname(ae), "./dir/file with space");
 674         assertEqualInt(archive_entry_uid(ae), 18);
 675         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0644);
 676
 677         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 678         assertEqualString(archive_entry_pathname(ae), "./file with space");
 679         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0644);
 680
 681         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 682         assertEqualString(archive_entry_pathname(ae), "./dir2");
 683         assertEqualInt(archive_entry_mode(ae), AE_IFDIR | 0755);
 684
 685         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 686         assertEqualString(archive_entry_pathname(ae), "./dir2/dir3a");
 687         assertEqualInt(archive_entry_mode(ae), AE_IFDIR | 0755);
 688
 689         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 690         assertEqualInt(6, archive_file_count(a));
 691         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 692         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 693 }
 694
 695 /*
 696  * Test for a format that NetBSD mtree -D generates.
 697  */
 698 DEFINE_TEST(test_read_format_mtree_nomagic_v2_netbsd_form)
 699 {
 700         const char reffile[] = "test_read_format_mtree_nomagic3.mtree";
 701         char buff[16];
 702         struct archive_entry *ae;
 703         struct archive *a;
 704         FILE *f;
 705
 706         extract_reference_file(reffile);
 707
 708         assert((a = archive_read_new()) != NULL);
 709         assertEqualIntA(a, ARCHIVE_OK,
 710             archive_read_support_filter_all(a));
 711         assertEqualIntA(a, ARCHIVE_OK,
 712             archive_read_support_format_all(a));
 713         assertEqualIntA(a, ARCHIVE_OK,
 714             archive_read_set_options(a, "mtree:checkfs"));
 715         assertEqualIntA(a, ARCHIVE_OK,
 716             archive_read_open_filename(a, reffile, 11));
 717
 718         /*
 719          * Read "file", whose data is available on disk.
 720          */
 721         f = fopen("file", "wb");
 722         assert(f != NULL);
 723         assertEqualInt(3, fwrite("hi\n", 1, 3, f));
 724         fclose(f);
 725         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 726         assertEqualInt(archive_format(a), ARCHIVE_FORMAT_MTREE);
 727         assertEqualString(archive_entry_pathname(ae), "./file");
 728         assertEqualInt(archive_entry_uid(ae), 18);
 729         assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
 730         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0123);
 731         assertEqualInt(archive_entry_size(ae), 3);
 732         assertEqualInt(3, archive_read_data(a, buff, 3));
 733         assertEqualMem(buff, "hi\n", 3);
 734
 735         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 736         assertEqualString(archive_entry_pathname(ae), "./dir");
 737         assertEqualInt(archive_entry_mode(ae), AE_IFDIR | 0755);
 738
 739         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 740         assertEqualString(archive_entry_pathname(ae), "./dir/file with space");
 741         assertEqualInt(archive_entry_uid(ae), 18);
 742         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0644);
 743
 744         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 745         assertEqualString(archive_entry_pathname(ae), "./file with space");
 746         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0644);
 747
 748         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 749         assertEqualString(archive_entry_pathname(ae), "./dir2");
 750         assertEqualInt(archive_entry_mode(ae), AE_IFDIR | 0755);
 751
 752         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 753         assertEqualString(archive_entry_pathname(ae), "./dir2/dir3a");
 754         assertEqualInt(archive_entry_mode(ae), AE_IFDIR | 0755);
 755
 756         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 757         assertEqualInt(6, archive_file_count(a));
 758         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 759         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 760 }
 761
 762 /*
 763  * We should get a warning if the contents file doesn't exist.
 764  */
 765 DEFINE_TEST(test_read_format_mtree_nonexistent_contents_file)
 766 {
 767         static char archive[] =
 768             "#mtree\n"
 769             "a type=file contents=nonexistent_file\n";
 770         struct archive_entry *ae;
 771         struct archive *a;
 772
 773         assert((a = archive_read_new()) != NULL);
 774         assertEqualIntA(a, ARCHIVE_OK,
 775             archive_read_support_filter_all(a));
 776         assertEqualIntA(a, ARCHIVE_OK,
 777             archive_read_support_format_all(a));
 778         assertEqualIntA(a, ARCHIVE_OK,
 779             archive_read_set_options(a, "mtree:checkfs"));
 780         assertEqualIntA(a, ARCHIVE_OK,
 781             archive_read_open_memory(a, archive, sizeof(archive)));
 782         assertEqualIntA(a, ARCHIVE_WARN, archive_read_next_header(a, &ae));
 783         assert(strlen(archive_error_string(a)) > 0);
 784         assertEqualString(archive_entry_pathname(ae), "a");
 785         assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
 786
 787         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 788         assertEqualInt(1, archive_file_count(a));
 789         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 790         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 791 }
 792 /*
 793  * Check mtree file with non-printable ascii characters
 794  */
 795 DEFINE_TEST(test_read_format_mtree_noprint)
 796 {
 797         const char reffile[] = "test_read_format_mtree_noprint.mtree";
 798         struct archive_entry *ae;
 799         struct archive *a;
 800
 801         extract_reference_file(reffile);
 802
 803         assert((a = archive_read_new()) != NULL);
 804         assertEqualIntA(a, ARCHIVE_OK,
 805             archive_read_support_filter_all(a));
 806         assertEqualIntA(a, ARCHIVE_OK,
 807             archive_read_support_format_all(a));
 808         assertEqualIntA(a, ARCHIVE_OK,
 809             archive_read_open_filename(a, reffile, 11));
 810
 811         assertEqualIntA(a, ARCHIVE_FATAL, archive_read_next_header(a, &ae));
 812         assertEqualString("Can't parse line 3", archive_error_string(a));
 813
 814         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 815         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 816 }