contrib/libarchive/libarchive/test/test_read_format_cpio_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_cpio_filename_eucJP_UTF8)
  31 {
  32         const char *refname = "test_read_format_cpio_filename_eucjp.cpio";
  33         struct archive *a;
  34         struct archive_entry *ae;
  35
  36         /*
  37          * Read eucJP filename in en_US.UTF-8 with "hdrcharset=eucJP" option.
  38          */
  39         if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
  40                 skipping("en_US.UTF-8 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=eucJP")) {
  49                 skipping("This system cannot convert character-set"
  50                     " from eucJP to UTF-8.");
  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("\xe6\xbc\xa2\xe5\xad\x97.txt",
  59             archive_entry_pathname(ae));
  60         assertEqualInt(8, archive_entry_size(ae));
  61         assertEqualInt(archive_entry_is_encrypted(ae), 0);
  62         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
  63
  64         /* Verify regular file. */
  65         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
  66         assertEqualString("\xe8\xa1\xa8.txt", archive_entry_pathname(ae));
  67         assertEqualInt(4, archive_entry_size(ae));
  68         assertEqualInt(archive_entry_is_encrypted(ae), 0);
  69         assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
  70
  71
  72         /* End of archive. */
  73         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
  74
  75         /* Verify archive format. */
  76         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
  77         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
  78
  79         /* Close the archive. */
  80         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
  81 cleanup:
  82         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
  83 }
  84
  85 DEFINE_TEST(test_read_format_cpio_filename_UTF8_eucJP)
  86 {
  87         const char *refname = "test_read_format_cpio_filename_utf8_jp.cpio";
  88         struct archive *a;
  89         struct archive_entry *ae;
  90
  91         /*
  92          * Read UTF-8 filename in ja_JP.eucJP with "hdrcharset=UTF-8" option.
  93          */
  94         if (NULL == setlocale(LC_ALL, "ja_JP.eucJP")) {
  95                 skipping("ja_JP.eucJP locale not available on this system.");
  96                 return;
  97         }
  98         extract_reference_file(refname);
  99
 100         assert((a = archive_read_new()) != NULL);
 101         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 102         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 103         if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
 104                 skipping("This system cannot convert character-set"
 105                     " from UTF-8 to eucJP.");
 106                 goto cleanup;
 107         }
 108
 109         assertEqualIntA(a, ARCHIVE_OK,
 110             archive_read_open_filename(a, refname, 10240));
 111
 112         /* Verify regular file. */
 113         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 114         assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
 115         assertEqualString("\xb4\xc1\xbb\xfa.txt", archive_entry_pathname(ae));
 116         assertEqualInt(8, archive_entry_size(ae));
 117
 118         /* Verify regular file. */
 119         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 120         assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
 121         assertEqualString("\xc9\xbd.txt", archive_entry_pathname(ae));
 122         assertEqualInt(4, archive_entry_size(ae));
 123
 124
 125         /* End of archive. */
 126         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 127
 128         /* Verify archive format. */
 129         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 130         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 131
 132         /* Close the archive. */
 133         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 134 cleanup:
 135         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 136 }
 137
 138 DEFINE_TEST(test_read_format_cpio_filename_UTF8_UTF8_jp)
 139 {
 140         const char *refname = "test_read_format_cpio_filename_utf8_jp.cpio";
 141         struct archive *a;
 142         struct archive_entry *ae;
 143
 144         /*
 145          * Read UTF-8 filename in en_US.UTF-8 without "hdrcharset=UTF-8" option.
 146          */
 147         if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
 148                 skipping("en_US.UTF-8 locale not available on this system.");
 149                 return;
 150         }
 151         extract_reference_file(refname);
 152
 153         assert((a = archive_read_new()) != NULL);
 154         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 155         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 156         assertEqualIntA(a, ARCHIVE_OK,
 157             archive_read_open_filename(a, refname, 10240));
 158
 159         /* Verify regular file. */
 160         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 161         assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
 162         assertEqualString("\xe6\xbc\xa2\xe5\xad\x97.txt",
 163             archive_entry_pathname(ae));
 164         assertEqualInt(8, archive_entry_size(ae));
 165
 166         /* Verify regular file. */
 167         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 168         assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
 169         assertEqualString("\xe8\xa1\xa8.txt", archive_entry_pathname(ae));
 170         assertEqualInt(4, archive_entry_size(ae));
 171
 172
 173         /* End of archive. */
 174         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 175
 176         /* Verify archive format. */
 177         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 178         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 179
 180         /* Close the archive. */
 181         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 182         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 183 }
 184
 185 DEFINE_TEST(test_read_format_cpio_filename_CP866_KOI8R)
 186 {
 187         const char *refname = "test_read_format_cpio_filename_cp866.cpio";
 188         struct archive *a;
 189         struct archive_entry *ae;
 190
 191         /*
 192          * Read CP866 filename in ru_RU.KOI8-R with "hdrcharset=CP866" option.
 193          */
 194         if (NULL == setlocale(LC_ALL, "Russian_Russia.20866") &&
 195             NULL == setlocale(LC_ALL, "ru_RU.KOI8-R")) {
 196                 skipping("ru_RU.KOI8-R locale not available on this system.");
 197                 return;
 198         }
 199         extract_reference_file(refname);
 200
 201         assert((a = archive_read_new()) != NULL);
 202         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 203         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 204         if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP866")) {
 205                 skipping("This system cannot convert character-set"
 206                     " from CP866 to KOI8-R.");
 207                 goto cleanup;
 208         }
 209         assertEqualIntA(a, ARCHIVE_OK,
 210             archive_read_open_filename(a, refname, 10240));
 211
 212         /* Verify regular file. */
 213         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 214         assertEqualString("\xf0\xf2\xe9\xf7\xe5\xf4",
 215             archive_entry_pathname(ae));
 216         assertEqualInt(6, archive_entry_size(ae));
 217
 218         /* Verify regular file. */
 219         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 220         assertEqualString("\xd0\xd2\xc9\xd7\xc5\xd4",
 221             archive_entry_pathname(ae));
 222         assertEqualInt(6, archive_entry_size(ae));
 223
 224
 225         /* End of archive. */
 226         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 227
 228         /* Verify archive format. */
 229         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 230         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 231
 232         /* Close the archive. */
 233         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 234 cleanup:
 235         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 236 }
 237
 238 DEFINE_TEST(test_read_format_cpio_filename_CP866_UTF8)
 239 {
 240         const char *refname = "test_read_format_cpio_filename_cp866.cpio";
 241         struct archive *a;
 242         struct archive_entry *ae;
 243
 244         /*
 245          * Read CP866 filename in en_US.UTF-8 with "hdrcharset=CP866" option.
 246          */
 247         if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
 248                 skipping("en_US.UTF-8 locale not available on this system.");
 249                 return;
 250         }
 251         extract_reference_file(refname);
 252
 253         assert((a = archive_read_new()) != NULL);
 254         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 255         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 256         if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP866")) {
 257                 skipping("This system cannot convert character-set"
 258                     " from CP866 to UTF-8.");
 259                 goto cleanup;
 260         }
 261         assertEqualIntA(a, ARCHIVE_OK,
 262             archive_read_open_filename(a, refname, 10240));
 263
 264         /* Verify regular file. */
 265         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 266         assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2",
 267             archive_entry_pathname(ae));
 268         assertEqualInt(6, archive_entry_size(ae));
 269
 270         /* Verify regular file. */
 271         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 272         assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82",
 273             archive_entry_pathname(ae));
 274         assertEqualInt(6, archive_entry_size(ae));
 275
 276
 277         /* End of archive. */
 278         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 279
 280         /* Verify archive format. */
 281         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 282         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 283
 284         /* Close the archive. */
 285         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 286 cleanup:
 287         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 288 }
 289
 290 DEFINE_TEST(test_read_format_cpio_filename_KOI8R_CP866)
 291 {
 292         const char *refname = "test_read_format_cpio_filename_koi8r.cpio";
 293         struct archive *a;
 294         struct archive_entry *ae;
 295
 296         /*
 297          * Read KOI8-R filename in ru_RU.CP866 with "hdrcharset=KOI8-R" option.
 298          */
 299         if (NULL == setlocale(LC_ALL, "Russian_Russia.866") &&
 300             NULL == setlocale(LC_ALL, "ru_RU.CP866")) {
 301                 skipping("ru_RU.CP866 locale not available on this system.");
 302                 return;
 303         }
 304         extract_reference_file(refname);
 305
 306         assert((a = archive_read_new()) != NULL);
 307         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 308         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 309         if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) {
 310                 skipping("This system cannot convert character-set"
 311                     " from KOI8-R to CP866.");
 312                 goto cleanup;
 313         }
 314         assertEqualIntA(a, ARCHIVE_OK,
 315             archive_read_open_filename(a, refname, 10240));
 316
 317         /* Verify regular file. */
 318         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 319         assertEqualString("\x8f\x90\x88\x82\x85\x92",
 320             archive_entry_pathname(ae));
 321         assertEqualInt(6, archive_entry_size(ae));
 322
 323         /* Verify regular file. */
 324         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 325         assertEqualString("\xaf\xe0\xa8\xa2\xa5\xe2",
 326             archive_entry_pathname(ae));
 327         assertEqualInt(6, archive_entry_size(ae));
 328
 329
 330         /* End of archive. */
 331         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 332
 333         /* Verify archive format. */
 334         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 335         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 336
 337         /* Close the archive. */
 338         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 339 cleanup:
 340         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 341 }
 342
 343 DEFINE_TEST(test_read_format_cpio_filename_KOI8R_UTF8)
 344 {
 345         const char *refname = "test_read_format_cpio_filename_koi8r.cpio";
 346         struct archive *a;
 347         struct archive_entry *ae;
 348
 349         /*
 350          * Read KOI8-R filename in en_US.UTF-8 with "hdrcharset=KOI8-R" option.
 351          */
 352         if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
 353                 skipping("en_US.UTF-8 locale not available on this system.");
 354                 return;
 355         }
 356         extract_reference_file(refname);
 357
 358         assert((a = archive_read_new()) != NULL);
 359         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 360         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 361         if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) {
 362                 skipping("This system cannot convert character-set"
 363                     " from KOI8-R to UTF-8.");
 364                 goto cleanup;
 365         }
 366         assertEqualIntA(a, ARCHIVE_OK,
 367             archive_read_open_filename(a, refname, 10240));
 368
 369         /* Verify regular file. */
 370         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 371         assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2",
 372             archive_entry_pathname(ae));
 373         assertEqualInt(6, archive_entry_size(ae));
 374
 375         /* Verify regular file. */
 376         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 377         assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82",
 378             archive_entry_pathname(ae));
 379         assertEqualInt(6, archive_entry_size(ae));
 380
 381
 382         /* End of archive. */
 383         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 384
 385         /* Verify archive format. */
 386         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 387         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 388
 389         /* Close the archive. */
 390         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 391 cleanup:
 392         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 393 }
 394
 395 DEFINE_TEST(test_read_format_cpio_filename_UTF8_KOI8R)
 396 {
 397         const char *refname = "test_read_format_cpio_filename_utf8_ru.cpio";
 398         struct archive *a;
 399         struct archive_entry *ae;
 400
 401         /*
 402          * Read UTF-8 filename in ru_RU.KOI8-R with "hdrcharset=UTF-8" option.
 403          */
 404         if (NULL == setlocale(LC_ALL, "Russian_Russia.20866") &&
 405             NULL == setlocale(LC_ALL, "ru_RU.KOI8-R")) {
 406                 skipping("ru_RU.KOI8-R locale not available on this system.");
 407                 return;
 408         }
 409         extract_reference_file(refname);
 410
 411         assert((a = archive_read_new()) != NULL);
 412         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 413         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 414         if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
 415                 skipping("This system cannot convert character-set"
 416                     " from UTF-8 to KOI8-R.");
 417                 goto cleanup;
 418         }
 419         assertEqualIntA(a, ARCHIVE_OK,
 420             archive_read_open_filename(a, refname, 10240));
 421
 422         /* Verify regular file. */
 423         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 424         assertEqualString("\xf0\xf2\xe9\xf7\xe5\xf4",
 425             archive_entry_pathname(ae));
 426         assertEqualInt(6, archive_entry_size(ae));
 427
 428         /* Verify regular file. */
 429         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 430         assertEqualString("\xd0\xd2\xc9\xd7\xc5\xd4",
 431             archive_entry_pathname(ae));
 432         assertEqualInt(6, archive_entry_size(ae));
 433
 434
 435         /* End of archive. */
 436         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 437
 438         /* Verify archive format. */
 439         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 440         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 441
 442         /* Close the archive. */
 443         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 444 cleanup:
 445         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 446 }
 447
 448 DEFINE_TEST(test_read_format_cpio_filename_UTF8_CP866)
 449 {
 450         const char *refname = "test_read_format_cpio_filename_utf8_ru.cpio";
 451         struct archive *a;
 452         struct archive_entry *ae;
 453
 454         /*
 455          * Read UTF-8 filename in ru_RU.CP866 with "hdrcharset=UTF-8" option.
 456          */
 457         if (NULL == setlocale(LC_ALL, "Russian_Russia.866") &&
 458                 NULL == setlocale(LC_ALL, "ru_RU.CP866")) {
 459                 skipping("ru_RU.CP866 locale not available on this system.");
 460                 return;
 461         }
 462         extract_reference_file(refname);
 463
 464         assert((a = archive_read_new()) != NULL);
 465         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 466         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 467         if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
 468                 skipping("This system cannot convert character-set"
 469                     " from UTF-8 to CP866.");
 470                 goto cleanup;
 471         }
 472         assertEqualIntA(a, ARCHIVE_OK,
 473             archive_read_open_filename(a, refname, 10240));
 474
 475         /* Verify regular file. */
 476         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 477         assertEqualString("\x8f\x90\x88\x82\x85\x92",
 478             archive_entry_pathname(ae));
 479         assertEqualInt(6, archive_entry_size(ae));
 480
 481         /* Verify regular file. */
 482         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 483         assertEqualString("\xaf\xe0\xa8\xa2\xa5\xe2",
 484             archive_entry_pathname(ae));
 485         assertEqualInt(6, archive_entry_size(ae));
 486
 487
 488         /* End of archive. */
 489         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 490
 491         /* Verify archive format. */
 492         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 493         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 494
 495         /* Close the archive. */
 496         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 497 cleanup:
 498         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 499 }
 500
 501 DEFINE_TEST(test_read_format_cpio_filename_UTF8_UTF8_ru)
 502 {
 503         const char *refname = "test_read_format_cpio_filename_utf8_ru.cpio";
 504         struct archive *a;
 505         struct archive_entry *ae;
 506
 507         /*
 508          * Read UTF-8 filename in en_US.UTF-8 without "hdrcharset=UTF-8" option.
 509          */
 510         if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
 511                 skipping("en_US.UTF-8 locale not available on this system.");
 512                 return;
 513         }
 514         extract_reference_file(refname);
 515
 516         assert((a = archive_read_new()) != NULL);
 517         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 518         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 519         assertEqualIntA(a, ARCHIVE_OK,
 520             archive_read_open_filename(a, refname, 10240));
 521
 522         /* Verify regular file. */
 523         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 524         assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2",
 525             archive_entry_pathname(ae));
 526         assertEqualInt(6, archive_entry_size(ae));
 527
 528         /* Verify regular file. */
 529         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 530         assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82",
 531             archive_entry_pathname(ae));
 532         assertEqualInt(6, archive_entry_size(ae));
 533
 534
 535         /* End of archive. */
 536         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 537
 538         /* Verify archive format. */
 539         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 540         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 541
 542         /* Close the archive. */
 543         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 544         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 545 }
 546
 547 DEFINE_TEST(test_read_format_cpio_filename_eucJP_CP932)
 548 {
 549         const char *refname = "test_read_format_cpio_filename_eucjp.cpio";
 550         struct archive *a;
 551         struct archive_entry *ae;
 552
 553         /*
 554          * Read eucJP filename in CP932/SJIS with "hdrcharset=eucJP" option.
 555          */
 556         if (NULL == setlocale(LC_ALL, "Japanese_Japan") &&
 557             NULL == setlocale(LC_ALL, "ja_JP.SJIS")) {
 558                 skipping("CP932 locale not available on this system.");
 559                 return;
 560         }
 561         extract_reference_file(refname);
 562
 563         assert((a = archive_read_new()) != NULL);
 564         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 565         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 566         if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=eucJP")) {
 567                 skipping("This system cannot convert character-set"
 568                     " from eucJP.");
 569                 goto cleanup;
 570         }
 571         assertEqualIntA(a, ARCHIVE_OK,
 572             archive_read_open_filename(a, refname, 10240));
 573
 574         /* Verify regular file. */
 575         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 576         assertEqualString("\x8a\xbf\x8e\x9a.txt", archive_entry_pathname(ae));
 577         assertEqualInt(8, archive_entry_size(ae));
 578
 579         /* Verify regular file. */
 580         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 581         assertEqualString("\x95\x5c.txt", archive_entry_pathname(ae));
 582         assertEqualInt(4, archive_entry_size(ae));
 583
 584
 585         /* End of archive. */
 586         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 587
 588         /* Verify archive format. */
 589         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 590         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 591
 592         /* Close the archive. */
 593         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 594 cleanup:
 595         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 596 }
 597
 598 DEFINE_TEST(test_read_format_cpio_filename_UTF8_CP932)
 599 {
 600         const char *refname = "test_read_format_cpio_filename_utf8_jp.cpio";
 601         struct archive *a;
 602         struct archive_entry *ae;
 603
 604         /*
 605          * Read UTF-8 filename in CP932/SJIS with "hdrcharset=UTF-8" option.
 606          */
 607         if (NULL == setlocale(LC_ALL, "Japanese_Japan") &&
 608             NULL == setlocale(LC_ALL, "ja_JP.SJIS")) {
 609                 skipping("CP932 locale not available on this system.");
 610                 return;
 611         }
 612         extract_reference_file(refname);
 613
 614         assert((a = archive_read_new()) != NULL);
 615         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 616         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 617         if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
 618                 skipping("This system cannot convert character-set"
 619                     " from UTF-8 to CP932.");
 620                 goto cleanup;
 621         }
 622         assertEqualIntA(a, ARCHIVE_OK,
 623             archive_read_open_filename(a, refname, 10240));
 624
 625         /* Verify regular file. */
 626         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 627         assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
 628         assertEqualString("\x8a\xbf\x8e\x9a.txt", archive_entry_pathname(ae));
 629         assertEqualInt(8, archive_entry_size(ae));
 630
 631         /* Verify regular file. */
 632         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 633         assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
 634         assertEqualString("\x95\x5c.txt", archive_entry_pathname(ae));
 635         assertEqualInt(4, archive_entry_size(ae));
 636
 637         /* End of archive. */
 638         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 639
 640         /* Verify archive format. */
 641         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 642         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 643
 644         /* Close the archive. */
 645         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 646 cleanup:
 647         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 648 }
 649
 650 DEFINE_TEST(test_read_format_cpio_filename_CP866_CP1251)
 651 {
 652         const char *refname = "test_read_format_cpio_filename_cp866.cpio";
 653         struct archive *a;
 654         struct archive_entry *ae;
 655
 656         /*
 657          * Read CP866 filename in CP1251 with "hdrcharset=CP866" option.
 658          */
 659         if (NULL == setlocale(LC_ALL, "Russian_Russia") &&
 660             NULL == setlocale(LC_ALL, "ru_RU.CP1251")) {
 661                 skipping("CP1251 locale not available on this system.");
 662                 return;
 663         }
 664         extract_reference_file(refname);
 665
 666         assert((a = archive_read_new()) != NULL);
 667         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 668         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 669         if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP866")) {
 670                 skipping("This system cannot convert character-set"
 671                     " from CP866 to CP1251.");
 672                 goto cleanup;
 673         }
 674         assertEqualIntA(a, ARCHIVE_OK,
 675             archive_read_open_filename(a, refname, 10240));
 676
 677         /* Verify regular file. */
 678         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 679         assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2",
 680             archive_entry_pathname(ae));
 681         assertEqualInt(6, archive_entry_size(ae));
 682
 683         /* Verify regular file. */
 684         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 685         assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2",
 686             archive_entry_pathname(ae));
 687         assertEqualInt(6, archive_entry_size(ae));
 688
 689
 690         /* End of archive. */
 691         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 692
 693         /* Verify archive format. */
 694         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 695         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 696
 697         /* Close the archive. */
 698         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 699 cleanup:
 700         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 701 }
 702
 703 /*
 704  * This test only for Windows platform because other archiver
 705  * applications on Windows translate CP1251 filenames into CP866
 706  * filenames and store it in the cpio file and so we should read
 707  * it by default on Windows.
 708  */
 709 DEFINE_TEST(test_read_format_cpio_filename_CP866_CP1251_win)
 710 {
 711         const char *refname = "test_read_format_cpio_filename_cp866.cpio";
 712         struct archive *a;
 713         struct archive_entry *ae;
 714
 715         /*
 716          * Read CP866 filename in CP1251 without "hdrcharset=CP866" option.
 717          */
 718         if (NULL == setlocale(LC_ALL, "Russian_Russia")) {
 719                 skipping("Russian_Russia locale not available on this system.");
 720                 return;
 721         }
 722         extract_reference_file(refname);
 723
 724         assert((a = archive_read_new()) != NULL);
 725         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 726         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 727         assertEqualIntA(a, ARCHIVE_OK,
 728             archive_read_open_filename(a, refname, 10240));
 729
 730         /* Verify regular file. */
 731         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 732         assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2",
 733             archive_entry_pathname(ae));
 734         assertEqualInt(6, archive_entry_size(ae));
 735
 736         /* Verify regular file. */
 737         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 738         assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2",
 739             archive_entry_pathname(ae));
 740         assertEqualInt(6, archive_entry_size(ae));
 741
 742
 743         /* End of archive. */
 744         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 745
 746         /* Verify archive format. */
 747         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 748         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 749
 750         /* Close the archive. */
 751         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 752         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 753 }
 754
 755 DEFINE_TEST(test_read_format_cpio_filename_KOI8R_CP1251)
 756 {
 757         const char *refname = "test_read_format_cpio_filename_koi8r.cpio";
 758         struct archive *a;
 759         struct archive_entry *ae;
 760
 761         /*
 762          * Read KOI8-R filename in CP1251 with "hdrcharset=KOI8-R" option.
 763          */
 764         if (NULL == setlocale(LC_ALL, "Russian_Russia") &&
 765             NULL == setlocale(LC_ALL, "ru_RU.CP1251")) {
 766                 skipping("CP1251 locale not available on this system.");
 767                 return;
 768         }
 769         extract_reference_file(refname);
 770
 771         assert((a = archive_read_new()) != NULL);
 772         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 773         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 774         if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) {
 775                 skipping("This system cannot convert character-set"
 776                     " from KOI8-R to CP1251.");
 777                 goto cleanup;
 778         }
 779         assertEqualIntA(a, ARCHIVE_OK,
 780             archive_read_open_filename(a, refname, 10240));
 781
 782         /* Verify regular file. */
 783         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 784         assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2",
 785             archive_entry_pathname(ae));
 786         assertEqualInt(6, archive_entry_size(ae));
 787
 788         /* Verify regular file. */
 789         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 790         assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2",
 791             archive_entry_pathname(ae));
 792         assertEqualInt(6, archive_entry_size(ae));
 793
 794
 795         /* End of archive. */
 796         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 797
 798         /* Verify archive format. */
 799         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 800         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 801
 802         /* Close the archive. */
 803         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 804 cleanup:
 805         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 806 }
 807
 808 DEFINE_TEST(test_read_format_cpio_filename_UTF8_CP1251)
 809 {
 810         const char *refname = "test_read_format_cpio_filename_utf8_ru.cpio";
 811         struct archive *a;
 812         struct archive_entry *ae;
 813
 814         /*
 815          * Read KOI8-R filename in CP1251 with "hdrcharset=KOI8-R" option.
 816          */
 817         if (NULL == setlocale(LC_ALL, "Russian_Russia") &&
 818             NULL == setlocale(LC_ALL, "ru_RU.CP1251")) {
 819                 skipping("CP1251 locale not available on this system.");
 820                 return;
 821         }
 822         extract_reference_file(refname);
 823
 824         assert((a = archive_read_new()) != NULL);
 825         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 826         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 827         if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
 828                 skipping("This system cannot convert character-set"
 829                     " from UTF-8 to CP1251.");
 830                 goto cleanup;
 831         }
 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         assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2",
 838             archive_entry_pathname(ae));
 839         assertEqualInt(6, archive_entry_size(ae));
 840
 841         /* Verify regular file. */
 842         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 843         assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2",
 844             archive_entry_pathname(ae));
 845         assertEqualInt(6, archive_entry_size(ae));
 846
 847
 848         /* End of archive. */
 849         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 850
 851         /* Verify archive format. */
 852         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 853         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 854
 855         /* Close the archive. */
 856         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 857 cleanup:
 858         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 859 }
 860