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