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