contrib/libarchive/libarchive/test/test_read_format_zip_filename.c

   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 sencod 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 }