1 /*- 2 * Copyright (c) 2011 Michihiro NAKAJIMA 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 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. 13 * 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. 24 */ 25 #include "test.h" 26 __FBSDID("$FreeBSD"); 27 28 #include <locale.h> 29 30 DEFINE_TEST(test_read_format_zip_filename_CP932_eucJP) 31 { 32 const char *refname = "test_read_format_zip_filename_cp932.zip"; 33 struct archive *a; 34 struct archive_entry *ae; 35 36 /* 37 * Read CP932 filename in ja_JP.eucJP with "hdrcharset=CP932" option. 38 */ 39 if (NULL == setlocale(LC_ALL, "ja_JP.eucJP")) { 40 skipping("ja_JP.eucJP locale not available on this system."); 41 return; 42 } 43 extract_reference_file(refname); 44 45 assert((a = archive_read_new()) != NULL); 46 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 47 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 48 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP932")) { 49 skipping("This system cannot convert character-set" 50 " from CP932 to eucJP."); 51 goto cleanup; 52 } 53 assertEqualIntA(a, ARCHIVE_OK, 54 archive_read_open_filename(a, refname, 10240)); 55 56 /* Verify regular file. */ 57 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 58 assertEqualString( 59 "\xc9\xbd\xa4\xc0\xa4\xe8\x2f\xb0\xec\xcd\xf7\xc9\xbd\x2e\x74\x78\x74", 60 archive_entry_pathname(ae)); 61 assertEqualInt(5, archive_entry_size(ae)); 62 assertEqualInt(archive_entry_is_encrypted(ae), 0); 63 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 64 65 /* Verify regular file. */ 66 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 67 assertEqualString( 68 "\xc9\xbd\xa4\xc0\xa4\xe8\x2f\xb4\xc1\xbb\xfa\x2e\x74\x78\x74", 69 archive_entry_pathname(ae)); 70 assertEqualInt(5, archive_entry_size(ae)); 71 assertEqualInt(archive_entry_is_encrypted(ae), 0); 72 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 73 74 75 /* End of archive. */ 76 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 77 assertEqualInt(archive_entry_is_encrypted(ae), 0); 78 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 79 80 /* Verify archive format. */ 81 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 82 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a)); 83 84 /* Close the archive. */ 85 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 86 cleanup: 87 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 88 } 89 90 DEFINE_TEST(test_read_format_zip_filename_CP932_UTF8) 91 { 92 const char *refname = "test_read_format_zip_filename_cp932.zip"; 93 struct archive *a; 94 struct archive_entry *ae; 95 96 /* 97 * Read CP932 filename in en_US.UTF-8 with "hdrcharset=CP932" option. 98 */ 99 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) { 100 skipping("en_US.UTF-8 locale not available on this system."); 101 return; 102 } 103 extract_reference_file(refname); 104 105 assert((a = archive_read_new()) != NULL); 106 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 107 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 108 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP932")) { 109 skipping("This system cannot convert character-set" 110 " from CP932 to UTF-8."); 111 goto cleanup; 112 } 113 assertEqualIntA(a, ARCHIVE_OK, 114 archive_read_open_filename(a, refname, 10240)); 115 116 /* Verify regular file. */ 117 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 118 assertEqualInt(archive_entry_is_encrypted(ae), 0); 119 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 120 #if defined(__APPLE__) 121 /* Compare NFD string. */ 122 assertEqualUTF8String( 123 "\xe8\xa1\xa8\xe3\x81\x9f\xe3\x82\x99\xe3\x82\x88\x2f" 124 "\xe4\xb8\x80\xe8\xa6\xa7\xe8\xa1\xa8\x2e\x74\x78\x74", 125 archive_entry_pathname(ae)); 126 #else 127 /* Compare NFC string. */ 128 assertEqualUTF8String( 129 "\xe8\xa1\xa8\xe3\x81\xa0\xe3\x82\x88\x2f" 130 "\xe4\xb8\x80\xe8\xa6\xa7\xe8\xa1\xa8\x2e\x74\x78\x74", 131 archive_entry_pathname(ae)); 132 #endif 133 assertEqualInt(5, archive_entry_size(ae)); 134 135 /* Verify regular file. */ 136 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 137 assertEqualInt(archive_entry_is_encrypted(ae), 0); 138 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 139 #if defined(__APPLE__) 140 /* Compare NFD string. */ 141 assertEqualUTF8String( 142 "\xe8\xa1\xa8\xe3\x81\x9f\xe3\x82\x99\xe3\x82\x88\x2f" 143 "\xe6\xbc\xa2\xe5\xad\x97\x2e\x74\x78\x74", 144 archive_entry_pathname(ae)); 145 #else 146 /* Compare NFC string. */ 147 assertEqualUTF8String( 148 "\xe8\xa1\xa8\xe3\x81\xa0\xe3\x82\x88\x2f" 149 "\xe6\xbc\xa2\xe5\xad\x97\x2e\x74\x78\x74", 150 archive_entry_pathname(ae)); 151 #endif 152 assertEqualInt(5, archive_entry_size(ae)); 153 154 155 /* End of archive. */ 156 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 157 158 /* Verify archive format. */ 159 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 160 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a)); 161 162 /* Close the archive. */ 163 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 164 cleanup: 165 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 166 } 167 168 DEFINE_TEST(test_read_format_zip_filename_UTF8_eucJP) 169 { 170 const char *refname = "test_read_format_zip_filename_utf8_jp.zip"; 171 struct archive *a; 172 struct archive_entry *ae; 173 174 /* 175 * Read UTF-8 filename in ja_JP.eucJP without charset option 176 * because the file name in the sample file is UTF-8 and 177 * Bit 11 of its general purpose bit flag is set. 178 */ 179 if (NULL == setlocale(LC_ALL, "ja_JP.eucJP")) { 180 skipping("ja_JP.eucJP locale not availablefilename_ on " 181 "this system."); 182 return; 183 } 184 extract_reference_file(refname); 185 assert((a = archive_read_new()) != NULL); 186 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 187 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) { 188 skipping("This system cannot convert character-set" 189 " from UTF-8 to eucJP."); 190 goto cleanup; 191 } 192 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 193 194 assert((a = archive_read_new()) != NULL); 195 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 196 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 197 assertEqualIntA(a, ARCHIVE_OK, 198 archive_read_open_filename(a, refname, 10240)); 199 200 /* Verify directory file. */ 201 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 202 assertEqualInt(AE_IFDIR, archive_entry_filetype(ae)); 203 assertEqualString("\xc9\xbd\xa4\xc0\xa4\xe8\x2f", 204 archive_entry_pathname(ae)); 205 assertEqualInt(0, archive_entry_size(ae)); 206 assertEqualInt(archive_entry_is_encrypted(ae), 0); 207 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 208 209 /* Verify regular file. */ 210 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 211 assertEqualInt(AE_IFREG, archive_entry_filetype(ae)); 212 assertEqualString( 213 "\xc9\xbd\xa4\xc0\xa4\xe8\x2f\xb0\xec\xcd\xf7\xc9\xbd\x2e\x74\x78\x74", 214 archive_entry_pathname(ae)); 215 assertEqualInt(5, archive_entry_size(ae)); 216 assertEqualInt(archive_entry_is_encrypted(ae), 0); 217 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 218 219 /* Verify regular file. */ 220 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 221 assertEqualInt(AE_IFREG, archive_entry_filetype(ae)); 222 assertEqualString( 223 "\xc9\xbd\xa4\xc0\xa4\xe8\x2f\xb4\xc1\xbb\xfa\x2e\x74\x78\x74", 224 archive_entry_pathname(ae)); 225 assertEqualInt(5, archive_entry_size(ae)); 226 assertEqualInt(archive_entry_is_encrypted(ae), 0); 227 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 228 229 230 /* End of archive. */ 231 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 232 233 /* Verify archive format. */ 234 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 235 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a)); 236 237 /* Close the archive. */ 238 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 239 cleanup: 240 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 241 } 242 243 DEFINE_TEST(test_read_format_zip_filename_UTF8_UTF8) 244 { 245 const char *refname = "test_read_format_zip_filename_utf8_jp.zip"; 246 struct archive *a; 247 struct archive_entry *ae; 248 249 /* 250 * Read UTF-8 filename in en_US.UTF-8 without charset option 251 * because the file name in the sample file is UTF-8 and 252 * Bit 11 of its general purpose bit flag is set. 253 */ 254 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) { 255 skipping("en_US.UTF-8 locale not available on this system."); 256 return; 257 } 258 extract_reference_file(refname); 259 260 assert((a = archive_read_new()) != NULL); 261 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 262 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 263 assertEqualIntA(a, ARCHIVE_OK, 264 archive_read_open_filename(a, refname, 10240)); 265 266 /* Verify directory file. */ 267 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 268 assertEqualInt(AE_IFDIR, archive_entry_filetype(ae)); 269 #if defined(__APPLE__) 270 /* Compare NFD string. */ 271 assertEqualUTF8String( 272 "\xe8\xa1\xa8\xe3\x81\x9f\xe3\x82\x99\xe3\x82\x88\x2f", 273 archive_entry_pathname(ae)); 274 #else 275 /* Compare NFC string. */ 276 assertEqualUTF8String( 277 "\xe8\xa1\xa8\xe3\x81\xa0\xe3\x82\x88\x2f", 278 archive_entry_pathname(ae)); 279 #endif 280 assertEqualInt(0, archive_entry_size(ae)); 281 assertEqualInt(archive_entry_is_encrypted(ae), 0); 282 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 283 284 /* Verify regular file. */ 285 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 286 assertEqualInt(AE_IFREG, archive_entry_filetype(ae)); 287 #if defined(__APPLE__) 288 /* Compare NFD string. */ 289 assertEqualUTF8String( 290 "\xe8\xa1\xa8\xe3\x81\x9f\xe3\x82\x99\xe3\x82\x88\x2f" 291 "\xe4\xb8\x80\xe8\xa6\xa7\xe8\xa1\xa8\x2e\x74\x78\x74", 292 archive_entry_pathname(ae)); 293 #else 294 /* Compare NFC string. */ 295 assertEqualUTF8String( 296 "\xe8\xa1\xa8\xe3\x81\xa0\xe3\x82\x88\x2f" 297 "\xe4\xb8\x80\xe8\xa6\xa7\xe8\xa1\xa8\x2e\x74\x78\x74", 298 archive_entry_pathname(ae)); 299 #endif 300 assertEqualInt(5, archive_entry_size(ae)); 301 assertEqualInt(archive_entry_is_encrypted(ae), 0); 302 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 303 304 /* Verify regular file. */ 305 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 306 assertEqualInt(AE_IFREG, archive_entry_filetype(ae)); 307 #if defined(__APPLE__) 308 /* Compare NFD string. */ 309 assertEqualUTF8String( 310 "\xe8\xa1\xa8\xe3\x81\x9f\xe3\x82\x99\xe3\x82\x88\x2f" 311 "\xe6\xbc\xa2\xe5\xad\x97\x2e\x74\x78\x74", 312 archive_entry_pathname(ae)); 313 #else 314 /* Compare NFC string. */ 315 assertEqualUTF8String( 316 "\xe8\xa1\xa8\xe3\x81\xa0\xe3\x82\x88\x2f" 317 "\xe6\xbc\xa2\xe5\xad\x97\x2e\x74\x78\x74", 318 archive_entry_pathname(ae)); 319 #endif 320 assertEqualInt(5, archive_entry_size(ae)); 321 assertEqualInt(archive_entry_is_encrypted(ae), 0); 322 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 323 324 325 /* End of archive. */ 326 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 327 328 /* Verify archive format. */ 329 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 330 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a)); 331 332 /* Close the archive. */ 333 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 334 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 335 } 336 337 DEFINE_TEST(test_read_format_zip_filename_CP866_KOI8R) 338 { 339 const char *refname = "test_read_format_zip_filename_cp866.zip"; 340 struct archive *a; 341 struct archive_entry *ae; 342 343 /* 344 * Read CP866 filename in ru_RU.KOI8-R with "hdrcharset=CP866" option. 345 */ 346 if (NULL == setlocale(LC_ALL, "Russian_Russia.20866") && 347 NULL == setlocale(LC_ALL, "ru_RU.KOI8-R")) { 348 skipping("ru_RU.KOI8-R locale not available on this system."); 349 return; 350 } 351 extract_reference_file(refname); 352 353 assert((a = archive_read_new()) != NULL); 354 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 355 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 356 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP866")) { 357 skipping("This system cannot convert character-set" 358 " from CP866 to KOI8-R."); 359 goto cleanup; 360 } 361 assertEqualIntA(a, ARCHIVE_OK, 362 archive_read_open_filename(a, refname, 10240)); 363 364 /* Verify regular file. */ 365 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 366 assertEqualString("\xf0\xf2\xe9\xf7\xe5\xf4", 367 archive_entry_pathname(ae)); 368 assertEqualInt(6, archive_entry_size(ae)); 369 assertEqualInt(archive_entry_is_encrypted(ae), 0); 370 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 371 372 /* Verify regular file. */ 373 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 374 assertEqualString("\xd0\xd2\xc9\xd7\xc5\xd4", 375 archive_entry_pathname(ae)); 376 assertEqualInt(6, archive_entry_size(ae)); 377 assertEqualInt(archive_entry_is_encrypted(ae), 0); 378 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 379 380 381 /* End of archive. */ 382 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 383 384 /* Verify archive format. */ 385 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 386 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a)); 387 388 /* Close the archive. */ 389 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 390 cleanup: 391 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 392 } 393 394 DEFINE_TEST(test_read_format_zip_filename_CP866_UTF8) 395 { 396 const char *refname = "test_read_format_zip_filename_cp866.zip"; 397 struct archive *a; 398 struct archive_entry *ae; 399 400 /* 401 * Read CP866 filename in en_US.UTF-8 with "hdrcharset=CP866" option. 402 */ 403 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) { 404 skipping("en_US.UTF-8 locale not available on this system."); 405 return; 406 } 407 extract_reference_file(refname); 408 409 assert((a = archive_read_new()) != NULL); 410 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 411 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 412 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP866")) { 413 skipping("This system cannot convert character-set" 414 " from CP866 to UTF-8."); 415 goto cleanup; 416 } 417 assertEqualIntA(a, ARCHIVE_OK, 418 archive_read_open_filename(a, refname, 10240)); 419 420 /* Verify regular file. */ 421 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 422 assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2", 423 archive_entry_pathname(ae)); 424 assertEqualInt(6, archive_entry_size(ae)); 425 assertEqualInt(archive_entry_is_encrypted(ae), 0); 426 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 427 428 /* Verify regular file. */ 429 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 430 assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82", 431 archive_entry_pathname(ae)); 432 assertEqualInt(6, archive_entry_size(ae)); 433 assertEqualInt(archive_entry_is_encrypted(ae), 0); 434 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 435 436 437 /* End of archive. */ 438 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 439 440 /* Verify archive format. */ 441 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 442 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a)); 443 444 /* Close the archive. */ 445 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 446 cleanup: 447 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 448 } 449 450 DEFINE_TEST(test_read_format_zip_filename_KOI8R_CP866) 451 { 452 const char *refname = "test_read_format_zip_filename_koi8r.zip"; 453 struct archive *a; 454 struct archive_entry *ae; 455 456 /* 457 * Read KOI8-R filename in ru_RU.CP866 with "hdrcharset=KOI8-R" option. 458 */ 459 if (NULL == setlocale(LC_ALL, "Russian_Russia.866") && 460 NULL == setlocale(LC_ALL, "ru_RU.CP866")) { 461 skipping("ru_RU.CP866 locale not available on this system."); 462 return; 463 } 464 extract_reference_file(refname); 465 466 assert((a = archive_read_new()) != NULL); 467 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 468 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 469 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) { 470 skipping("This system cannot convert character-set" 471 " from KOI8-R to CP866."); 472 goto cleanup; 473 } 474 assertEqualIntA(a, ARCHIVE_OK, 475 archive_read_open_filename(a, refname, 10240)); 476 477 /* Verify regular file. */ 478 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 479 assertEqualString("\xaf\xe0\xa8\xa2\xa5\xe2", 480 archive_entry_pathname(ae)); 481 assertEqualInt(6, archive_entry_size(ae)); 482 assertEqualInt(archive_entry_is_encrypted(ae), 0); 483 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 484 485 /* Verify regular file. */ 486 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 487 assertEqualString("\x8f\x90\x88\x82\x85\x92", 488 archive_entry_pathname(ae)); 489 assertEqualInt(6, archive_entry_size(ae)); 490 assertEqualInt(archive_entry_is_encrypted(ae), 0); 491 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 492 493 494 /* End of archive. */ 495 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 496 497 /* Verify archive format. */ 498 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 499 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a)); 500 501 /* Close the archive. */ 502 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 503 cleanup: 504 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 505 } 506 507 DEFINE_TEST(test_read_format_zip_filename_KOI8R_UTF8) 508 { 509 const char *refname = "test_read_format_zip_filename_koi8r.zip"; 510 struct archive *a; 511 struct archive_entry *ae; 512 513 /* 514 * Read KOI8-R filename in en_US.UTF-8 with "hdrcharset=KOI8-R" option. 515 */ 516 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) { 517 skipping("en_US.UTF-8 locale not available on this system."); 518 return; 519 } 520 extract_reference_file(refname); 521 522 assert((a = archive_read_new()) != NULL); 523 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 524 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 525 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) { 526 skipping("This system cannot convert character-set" 527 " from KOI8-R to UTF-8."); 528 goto cleanup; 529 } 530 assertEqualIntA(a, ARCHIVE_OK, 531 archive_read_open_filename(a, refname, 10240)); 532 533 /* Verify regular file. */ 534 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 535 assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82", 536 archive_entry_pathname(ae)); 537 assertEqualInt(6, archive_entry_size(ae)); 538 assertEqualInt(archive_entry_is_encrypted(ae), 0); 539 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 540 541 /* Verify regular file. */ 542 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 543 assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2", 544 archive_entry_pathname(ae)); 545 assertEqualInt(6, archive_entry_size(ae)); 546 assertEqualInt(archive_entry_is_encrypted(ae), 0); 547 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 548 549 550 /* End of archive. */ 551 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 552 553 /* Verify archive format. */ 554 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 555 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a)); 556 557 /* Close the archive. */ 558 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 559 cleanup: 560 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 561 } 562 563 DEFINE_TEST(test_read_format_zip_filename_UTF8_KOI8R) 564 { 565 const char *refname = "test_read_format_zip_filename_utf8_ru.zip"; 566 struct archive *a; 567 struct archive_entry *ae; 568 569 /* 570 * Read UTF-8 filename in ru_RU.KOI8-R with "hdrcharset=UTF-8" option. 571 */ 572 if (NULL == setlocale(LC_ALL, "Russian_Russia.20866") && 573 NULL == setlocale(LC_ALL, "ru_RU.KOI8-R")) { 574 skipping("ru_RU.KOI8-R locale not available on this system."); 575 return; 576 } 577 extract_reference_file(refname); 578 579 assert((a = archive_read_new()) != NULL); 580 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 581 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) { 582 skipping("This system cannot convert character-set" 583 " from UTF-8 to KOI8-R."); 584 goto cleanup; 585 } 586 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 587 588 /* Re-create a read archive object. */ 589 assert((a = archive_read_new()) != NULL); 590 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 591 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 592 assertEqualIntA(a, ARCHIVE_OK, 593 archive_read_open_filename(a, refname, 10240)); 594 595 /* Verify regular file. */ 596 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 597 assertEqualString("\xf0\xf2\xe9\xf7\xe5\xf4", 598 archive_entry_pathname(ae)); 599 assertEqualInt(6, archive_entry_size(ae)); 600 assertEqualInt(archive_entry_is_encrypted(ae), 0); 601 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 602 603 /* Verify regular file. */ 604 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 605 assertEqualString("\xd0\xd2\xc9\xd7\xc5\xd4", 606 archive_entry_pathname(ae)); 607 assertEqualInt(6, archive_entry_size(ae)); 608 assertEqualInt(archive_entry_is_encrypted(ae), 0); 609 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 610 611 612 /* End of archive. */ 613 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 614 615 /* Verify archive format. */ 616 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 617 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a)); 618 619 /* Close the archive. */ 620 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 621 cleanup: 622 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 623 } 624 625 DEFINE_TEST(test_read_format_zip_filename_UTF8_CP866) 626 { 627 const char *refname = "test_read_format_zip_filename_utf8_ru.zip"; 628 struct archive *a; 629 struct archive_entry *ae; 630 631 /* 632 * Read UTF-8 filename in ru_RU.CP866 without charset option 633 * because the file name in the sample file is UTF-8 and 634 * Bit 11 of its general purpose bit flag is set. 635 */ 636 if (NULL == setlocale(LC_ALL, "Russian_Russia.866") && 637 NULL == setlocale(LC_ALL, "ru_RU.CP866")) { 638 skipping("ru_RU.CP866 locale not available on this system."); 639 return; 640 } 641 extract_reference_file(refname); 642 643 assert((a = archive_read_new()) != NULL); 644 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 645 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 646 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) { 647 skipping("This system cannot convert character-set" 648 " from UTF-8 to CP866."); 649 goto cleanup; 650 } 651 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 652 653 /* Re-create a read archive object. */ 654 assert((a = archive_read_new()) != NULL); 655 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 656 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 657 assertEqualIntA(a, ARCHIVE_OK, 658 archive_read_open_filename(a, refname, 10240)); 659 660 /* Verify regular file. */ 661 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 662 assertEqualString("\x8f\x90\x88\x82\x85\x92", 663 archive_entry_pathname(ae)); 664 assertEqualInt(6, archive_entry_size(ae)); 665 assertEqualInt(archive_entry_is_encrypted(ae), 0); 666 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 667 668 /* Verify regular file. */ 669 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 670 assertEqualString("\xaf\xe0\xa8\xa2\xa5\xe2", 671 archive_entry_pathname(ae)); 672 assertEqualInt(6, archive_entry_size(ae)); 673 assertEqualInt(archive_entry_is_encrypted(ae), 0); 674 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 675 676 677 /* End of archive. */ 678 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 679 680 /* Verify archive format. */ 681 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 682 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a)); 683 684 /* Close the archive. */ 685 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 686 cleanup: 687 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 688 } 689 690 DEFINE_TEST(test_read_format_zip_filename_UTF8_UTF8_ru) 691 { 692 const char *refname = "test_read_format_zip_filename_utf8_ru.zip"; 693 struct archive *a; 694 struct archive_entry *ae; 695 696 /* 697 * Read UTF-8 filename in en_US.UTF-8 without charset option 698 * because the file name in the sample file is UTF-8 and 699 * Bit 11 of its general purpose bit flag is set. 700 */ 701 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) { 702 skipping("en_US.UTF-8 locale not available on this system."); 703 return; 704 } 705 extract_reference_file(refname); 706 707 assert((a = archive_read_new()) != NULL); 708 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 709 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 710 assertEqualIntA(a, ARCHIVE_OK, 711 archive_read_open_filename(a, refname, 10240)); 712 713 /* Verify regular file. */ 714 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 715 assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2", 716 archive_entry_pathname(ae)); 717 assertEqualInt(6, archive_entry_size(ae)); 718 assertEqualInt(archive_entry_is_encrypted(ae), 0); 719 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 720 721 /* Verify regular file. */ 722 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 723 assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82", 724 archive_entry_pathname(ae)); 725 assertEqualInt(6, archive_entry_size(ae)); 726 assertEqualInt(archive_entry_is_encrypted(ae), 0); 727 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 728 729 730 /* End of archive. */ 731 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 732 733 /* Verify archive format. */ 734 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 735 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a)); 736 737 /* Close the archive. */ 738 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 739 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 740 } 741 742 DEFINE_TEST(test_read_format_zip_filename_CP932_CP932) 743 { 744 const char *refname = "test_read_format_zip_filename_cp932.zip"; 745 struct archive *a; 746 struct archive_entry *ae; 747 748 /* 749 * Read CP932 filename in CP932/SJIS with "hdrcharset=CP932" option. 750 */ 751 if (NULL == setlocale(LC_ALL, "Japanese_Japan") && 752 NULL == setlocale(LC_ALL, "ja_JP.SJIS")) { 753 skipping("CP932 locale not available on this system."); 754 return; 755 } 756 extract_reference_file(refname); 757 758 assert((a = archive_read_new()) != NULL); 759 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 760 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 761 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP932")) { 762 skipping("This system cannot convert character-set" 763 " from CP932."); 764 goto cleanup; 765 } 766 assertEqualIntA(a, ARCHIVE_OK, 767 archive_read_open_filename(a, refname, 10240)); 768 769 /* Verify regular file. */ 770 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 771 assertEqualString( 772 "\x95\x5c\x82\xbe\x82\xe6\x2f\x88\xea\x97\x97\x95\x5c.txt", 773 archive_entry_pathname(ae)); 774 assertEqualInt(5, archive_entry_size(ae)); 775 assertEqualInt(archive_entry_is_encrypted(ae), 0); 776 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 777 778 /* Verify regular file. */ 779 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 780 assertEqualString( 781 "\x95\x5c\x82\xbe\x82\xe6\x2f\x8a\xbf\x8e\x9a.txt", 782 archive_entry_pathname(ae)); 783 assertEqualInt(5, archive_entry_size(ae)); 784 assertEqualInt(archive_entry_is_encrypted(ae), 0); 785 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 786 787 788 /* End of archive. */ 789 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 790 791 /* Verify archive format. */ 792 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 793 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a)); 794 795 /* Close the archive. */ 796 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 797 cleanup: 798 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 799 } 800 801 DEFINE_TEST(test_read_format_zip_filename_UTF8_CP932) 802 { 803 const char *refname = "test_read_format_zip_filename_utf8_jp.zip"; 804 struct archive *a; 805 struct archive_entry *ae; 806 807 /* 808 * Read UTF-8 filename in CP932/SJIS without charset option 809 * because the file name in the sample file is UTF-8 and 810 * Bit 11 of its general purpose bit flag is set. 811 */ 812 if (NULL == setlocale(LC_ALL, "Japanese_Japan") && 813 NULL == setlocale(LC_ALL, "ja_JP.SJIS")) { 814 skipping("CP932 locale not available on this system."); 815 return; 816 } 817 extract_reference_file(refname); 818 819 assert((a = archive_read_new()) != NULL); 820 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 821 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) { 822 skipping("This system cannot convert character-set" 823 " from UTF-8 to CP932."); 824 goto cleanup; 825 } 826 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 827 828 /* Re-create a read archive object. */ 829 assert((a = archive_read_new()) != NULL); 830 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 831 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 832 assertEqualIntA(a, ARCHIVE_OK, 833 archive_read_open_filename(a, refname, 10240)); 834 835 /* Verify regular file. */ 836 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 837 assertEqualInt(AE_IFDIR, archive_entry_filetype(ae)); 838 assertEqualString( 839 "\x95\x5c\x82\xbe\x82\xe6\x2f", 840 archive_entry_pathname(ae)); 841 assertEqualInt(0, archive_entry_size(ae)); 842 assertEqualInt(archive_entry_is_encrypted(ae), 0); 843 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 844 845 /* Verify directory file. */ 846 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 847 assertEqualInt(AE_IFREG, archive_entry_filetype(ae)); 848 assertEqualString( 849 "\x95\x5c\x82\xbe\x82\xe6\x2f\x88\xea\x97\x97\x95\x5c.txt", 850 archive_entry_pathname(ae)); 851 assertEqualInt(5, archive_entry_size(ae)); 852 assertEqualInt(archive_entry_is_encrypted(ae), 0); 853 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 854 855 /* Verify regular file. */ 856 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 857 assertEqualInt(AE_IFREG, archive_entry_filetype(ae)); 858 assertEqualString( 859 "\x95\x5c\x82\xbe\x82\xe6\x2f\x8a\xbf\x8e\x9a.txt", 860 archive_entry_pathname(ae)); 861 assertEqualInt(5, archive_entry_size(ae)); 862 assertEqualInt(archive_entry_is_encrypted(ae), 0); 863 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 864 865 /* End of archive. */ 866 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 867 868 /* Verify archive format. */ 869 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 870 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a)); 871 872 /* Close the archive. */ 873 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 874 cleanup: 875 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 876 } 877 878 DEFINE_TEST(test_read_format_zip_filename_CP866_CP1251) 879 { 880 const char *refname = "test_read_format_zip_filename_cp866.zip"; 881 struct archive *a; 882 struct archive_entry *ae; 883 884 /* 885 * Read CP866 filename in CP1251 with "hdrcharset=CP866" option. 886 */ 887 if (NULL == setlocale(LC_ALL, "Russian_Russia") && 888 NULL == setlocale(LC_ALL, "ru_RU.CP1251")) { 889 skipping("CP1251 locale not available on this system."); 890 return; 891 } 892 extract_reference_file(refname); 893 894 assert((a = archive_read_new()) != NULL); 895 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 896 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 897 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP866")) { 898 skipping("This system cannot convert character-set" 899 " from CP866 to CP1251."); 900 goto cleanup; 901 } 902 assertEqualIntA(a, ARCHIVE_OK, 903 archive_read_open_filename(a, refname, 10240)); 904 905 /* Verify regular file. */ 906 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 907 assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2", 908 archive_entry_pathname(ae)); 909 assertEqualInt(6, archive_entry_size(ae)); 910 assertEqualInt(archive_entry_is_encrypted(ae), 0); 911 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 912 913 /* Verify regular file. */ 914 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 915 assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2", 916 archive_entry_pathname(ae)); 917 assertEqualInt(6, archive_entry_size(ae)); 918 assertEqualInt(archive_entry_is_encrypted(ae), 0); 919 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 920 921 922 /* End of archive. */ 923 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 924 925 /* Verify archive format. */ 926 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 927 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a)); 928 929 /* Close the archive. */ 930 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 931 cleanup: 932 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 933 } 934 935 /* 936 * This test only for Windows platform because other archiver 937 * applications on Windows translate CP1251 filenames into CP866 938 * filenames and store it in the zip file and so we should read 939 * it by default on Windows. 940 */ 941 DEFINE_TEST(test_read_format_zip_filename_CP866_CP1251_win) 942 { 943 const char *refname = "test_read_format_zip_filename_cp866.zip"; 944 struct archive *a; 945 struct archive_entry *ae; 946 947 /* 948 * Read CP866 filename in CP1251 without "hdrcharset=CP866" option. 949 */ 950 if (NULL == setlocale(LC_ALL, "Russian_Russia")) { 951 skipping("Russian_Russia locale not available on this system."); 952 return; 953 } 954 extract_reference_file(refname); 955 956 assert((a = archive_read_new()) != NULL); 957 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 958 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 959 assertEqualIntA(a, ARCHIVE_OK, 960 archive_read_open_filename(a, refname, 10240)); 961 962 /* Verify regular file. */ 963 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 964 assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2", 965 archive_entry_pathname(ae)); 966 assertEqualInt(6, archive_entry_size(ae)); 967 assertEqualInt(archive_entry_is_encrypted(ae), 0); 968 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 969 970 /* Verify regular file. */ 971 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 972 assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2", 973 archive_entry_pathname(ae)); 974 assertEqualInt(6, archive_entry_size(ae)); 975 assertEqualInt(archive_entry_is_encrypted(ae), 0); 976 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 977 978 979 /* End of archive. */ 980 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 981 982 /* Verify archive format. */ 983 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 984 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a)); 985 986 /* Close the archive. */ 987 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 988 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 989 } 990 991 DEFINE_TEST(test_read_format_zip_filename_KOI8R_CP1251) 992 { 993 const char *refname = "test_read_format_zip_filename_koi8r.zip"; 994 struct archive *a; 995 struct archive_entry *ae; 996 997 /* 998 * Read KOI8-R filename in CP1251 with "hdrcharset=KOI8-R" option. 999 */ 1000 if (NULL == setlocale(LC_ALL, "Russian_Russia") && 1001 NULL == setlocale(LC_ALL, "ru_RU.CP1251")) { 1002 skipping("CP1251 locale not available on this system."); 1003 return; 1004 } 1005 extract_reference_file(refname); 1006 1007 assert((a = archive_read_new()) != NULL); 1008 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 1009 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 1010 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) { 1011 skipping("This system cannot convert character-set" 1012 " from KOI8-R to CP1251."); 1013 goto cleanup; 1014 } 1015 assertEqualIntA(a, ARCHIVE_OK, 1016 archive_read_open_filename(a, refname, 10240)); 1017 1018 /* Verify regular file. */ 1019 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 1020 assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2", 1021 archive_entry_pathname(ae)); 1022 assertEqualInt(6, archive_entry_size(ae)); 1023 assertEqualInt(archive_entry_is_encrypted(ae), 0); 1024 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 1025 1026 /* Verify regular file. */ 1027 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 1028 assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2", 1029 archive_entry_pathname(ae)); 1030 assertEqualInt(6, archive_entry_size(ae)); 1031 assertEqualInt(archive_entry_is_encrypted(ae), 0); 1032 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 1033 1034 1035 /* End of archive. */ 1036 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 1037 1038 /* Verify archive format. */ 1039 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 1040 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a)); 1041 1042 /* Close the archive. */ 1043 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 1044 cleanup: 1045 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 1046 } 1047 1048 DEFINE_TEST(test_read_format_zip_filename_UTF8_CP1251) 1049 { 1050 const char *refname = "test_read_format_zip_filename_utf8_ru.zip"; 1051 struct archive *a; 1052 struct archive_entry *ae; 1053 1054 /* 1055 * Read UTF-8 filename in CP1251 without charset option 1056 * because the file name in the sample file is UTF-8 and 1057 * Bit 11 of its general purpose bit flag is set. 1058 */ 1059 if (NULL == setlocale(LC_ALL, "Russian_Russia") && 1060 NULL == setlocale(LC_ALL, "ru_RU.CP1251")) { 1061 skipping("CP1251 locale not available on this system."); 1062 return; 1063 } 1064 extract_reference_file(refname); 1065 1066 assert((a = archive_read_new()) != NULL); 1067 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 1068 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) { 1069 skipping("This system cannot convert character-set" 1070 " from UTF-8 to CP1251."); 1071 goto cleanup; 1072 } 1073 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 1074 1075 /* Re-create a read archive object. */ 1076 assert((a = archive_read_new()) != NULL); 1077 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 1078 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 1079 assertEqualIntA(a, ARCHIVE_OK, 1080 archive_read_open_filename(a, refname, 10240)); 1081 1082 /* Verify regular file. */ 1083 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 1084 assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2", 1085 archive_entry_pathname(ae)); 1086 assertEqualInt(6, archive_entry_size(ae)); 1087 assertEqualInt(archive_entry_is_encrypted(ae), 0); 1088 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 1089 1090 /* Verify regular file. */ 1091 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 1092 assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2", 1093 archive_entry_pathname(ae)); 1094 assertEqualInt(6, archive_entry_size(ae)); 1095 assertEqualInt(archive_entry_is_encrypted(ae), 0); 1096 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 1097 1098 1099 /* End of archive. */ 1100 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 1101 1102 /* Verify archive format. */ 1103 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 1104 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a)); 1105 1106 /* Close the archive. */ 1107 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 1108 cleanup: 1109 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 1110 } 1111 1112 /* 1113 * The sample zip file was made in LANG=KOI8-R and it contains two 1114 * files the charset of which are different. 1115 * - the filename of first file is stored in KOI8-R. 1116 * - the filename of second file is stored in UTF-8. 1117 * 1118 * Whenever hdrcharset option is specified, we will correctly read the 1119 * filename of second file, which is stored in UTF-8. 1120 */ 1121 1122 DEFINE_TEST(test_read_format_zip_filename_KOI8R_UTF8_2) 1123 { 1124 const char *refname = "test_read_format_zip_filename_utf8_ru2.zip"; 1125 struct archive *a; 1126 struct archive_entry *ae; 1127 1128 /* 1129 * Read filename in en_US.UTF-8 with "hdrcharset=KOI8-R" option. 1130 */ 1131 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) { 1132 skipping("en_US.UTF-8 locale not available on this system."); 1133 return; 1134 } 1135 extract_reference_file(refname); 1136 1137 assert((a = archive_read_new()) != NULL); 1138 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 1139 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 1140 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) { 1141 skipping("This system cannot convert character-set" 1142 " from KOI8-R to UTF-8."); 1143 goto next_test; 1144 } 1145 assertEqualIntA(a, ARCHIVE_OK, 1146 archive_read_open_filename(a, refname, 10240)); 1147 1148 /* Verify regular first file. */ 1149 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 1150 assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2", 1151 archive_entry_pathname(ae)); 1152 assertEqualInt(6, archive_entry_size(ae)); 1153 assertEqualInt(archive_entry_is_encrypted(ae), 0); 1154 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 1155 1156 /* 1157 * Verify regular second file. 1158 * The filename is not translated because Bit 11 of its general 1159 * purpose bit flag is set and so we know the conversion is unneeded. 1160 */ 1161 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 1162 assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82", 1163 archive_entry_pathname(ae)); 1164 assertEqualInt(6, archive_entry_size(ae)); 1165 assertEqualInt(archive_entry_is_encrypted(ae), 0); 1166 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 1167 1168 1169 /* End of archive. */ 1170 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 1171 1172 /* Verify archive format. */ 1173 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 1174 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a)); 1175 1176 /* Close the archive. */ 1177 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 1178 next_test: 1179 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 1180 1181 /* 1182 * Read filename in en_US.UTF-8 without "hdrcharset=KOI8-R" option. 1183 * The filename we can properly read is only second file. 1184 */ 1185 assert((a = archive_read_new()) != NULL); 1186 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 1187 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 1188 assertEqualIntA(a, ARCHIVE_OK, 1189 archive_read_open_filename(a, refname, 10240)); 1190 1191 /* 1192 * Verify regular first file. 1193 * The filename is not translated to UTF-8 because Bit 11 of 1194 * its general purpose bit flag is *not* set and so there is 1195 * not way to know its charset. 1196 */ 1197 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 1198 /* A filename is in KOI8-R. */ 1199 assertEqualString("\xf0\xf2\xe9\xf7\xe5\xf4", 1200 archive_entry_pathname(ae)); 1201 assertEqualInt(6, archive_entry_size(ae)); 1202 assertEqualInt(archive_entry_is_encrypted(ae), 0); 1203 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 1204 1205 /* Verify regular file. */ 1206 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 1207 assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82", 1208 archive_entry_pathname(ae)); 1209 assertEqualInt(6, archive_entry_size(ae)); 1210 assertEqualInt(archive_entry_is_encrypted(ae), 0); 1211 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 1212 1213 1214 /* End of archive. */ 1215 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 1216 1217 /* Verify archive format. */ 1218 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 1219 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a)); 1220 1221 /* Close the archive. */ 1222 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 1223 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 1224 } 1225