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