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