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