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