1 /*-
2 * Copyright (c) 2008 Anselm Strauss
3 * Copyright (c) 2009 Joerg Sonnenberger
4 * Copyright (c) 2011-2012 Michihiro NAKAJIMA
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 /*
29 * Development supported by Google Summer of Code 2008.
30 */
31
32 /*
33 * The current implementation is very limited:
34 *
35 * - No encryption support.
36 * - No ZIP64 support.
37 * - No support for splitting and spanning.
38 * - Only supports regular file and folder entries.
39 *
40 * Note that generally data in ZIP files is little-endian encoded,
41 * with some exceptions.
42 *
43 * TODO: Since Libarchive is generally 64bit oriented, but this implementation
44 * does not yet support sizes exceeding 32bit, it is highly fragile for
45 * big archives. This should change when ZIP64 is finally implemented, otherwise
46 * some serious checking has to be done.
47 *
48 */
49
50 #include "archive_platform.h"
51 __FBSDID("$FreeBSD$");
52
53 #ifdef HAVE_ERRNO_H
54 #include <errno.h>
55 #endif
56 #ifdef HAVE_LANGINFO_H
57 #include <langinfo.h>
58 #endif
59 #ifdef HAVE_STDLIB_H
60 #include <stdlib.h>
61 #endif
62 #ifdef HAVE_STRING_H
63 #include <string.h>
64 #endif
65 #ifdef HAVE_ZLIB_H
66 #include <zlib.h>
67 #endif
68
69 #include "archive.h"
70 #include "archive_endian.h"
71 #include "archive_entry.h"
72 #include "archive_entry_locale.h"
73 #include "archive_private.h"
74 #include "archive_write_private.h"
75
76 #ifndef HAVE_ZLIB_H
77 #include "archive_crc32.h"
78 #endif
79
80 #define ZIP_SIGNATURE_LOCAL_FILE_HEADER 0x04034b50
81 #define ZIP_SIGNATURE_DATA_DESCRIPTOR 0x08074b50
82 #define ZIP_SIGNATURE_FILE_HEADER 0x02014b50
83 #define ZIP_SIGNATURE_CENTRAL_DIRECTORY_END 0x06054b50
84 #define ZIP_SIGNATURE_EXTRA_TIMESTAMP 0x5455
85 #define ZIP_SIGNATURE_EXTRA_NEW_UNIX 0x7875
86 #define ZIP_VERSION_EXTRACT 0x0014 /* ZIP version 2.0 is needed. */
87 #define ZIP_VERSION_BY 0x0314 /* Made by UNIX, using ZIP version 2.0. */
88 #define ZIP_FLAGS 0x08 /* Flagging bit 3 (count from 0) for using data descriptor. */
89 #define ZIP_FLAGS_UTF8_NAME (1 << 11)
90
91 enum compression {
92 COMPRESSION_STORE = 0
93 #ifdef HAVE_ZLIB_H
94 ,
95 COMPRESSION_DEFLATE = 8
96 #endif
97 };
98
99 static ssize_t archive_write_zip_data(struct archive_write *,
100 const void *buff, size_t s);
101 static int archive_write_zip_close(struct archive_write *);
102 static int archive_write_zip_free(struct archive_write *);
103 static int archive_write_zip_finish_entry(struct archive_write *);
104 static int archive_write_zip_header(struct archive_write *,
105 struct archive_entry *);
106 static int archive_write_zip_options(struct archive_write *,
107 const char *, const char *);
108 static unsigned int dos_time(const time_t);
109 static size_t path_length(struct archive_entry *);
110 static int write_path(struct archive_entry *, struct archive_write *);
111
112 #define LOCAL_FILE_HEADER_SIGNATURE 0
113 #define LOCAL_FILE_HEADER_VERSION 4
114 #define LOCAL_FILE_HEADER_FLAGS 6
115 #define LOCAL_FILE_HEADER_COMPRESSION 8
116 #define LOCAL_FILE_HEADER_TIMEDATE 10
117 #define LOCAL_FILE_HEADER_CRC32 14
118 #define LOCAL_FILE_HEADER_COMPRESSED_SIZE 18
119 #define LOCAL_FILE_HEADER_UNCOMPRESSED_SIZE 22
120 #define LOCAL_FILE_HEADER_FILENAME_LENGTH 26
121 #define LOCAL_FILE_HEADER_EXTRA_LENGTH 28
122 #define SIZE_LOCAL_FILE_HEADER 30
123
124 #define FILE_HEADER_SIGNATURE 0
125 #define FILE_HEADER_VERSION_BY 4
126 #define FILE_HEADER_VERSION_EXTRACT 6
127 #define FILE_HEADER_FLAGS 8
128 #define FILE_HEADER_COMPRESSION 10
129 #define FILE_HEADER_TIMEDATE 12
130 #define FILE_HEADER_CRC32 16
131 #define FILE_HEADER_COMPRESSED_SIZE 20
132 #define FILE_HEADER_UNCOMPRESSED_SIZE 24
133 #define FILE_HEADER_FILENAME_LENGTH 28
134 #define FILE_HEADER_EXTRA_LENGTH 30
135 #define FILE_HEADER_COMMENT_LENGTH 32
136 #define FILE_HEADER_DISK_NUMBER 34
137 #define FILE_HEADER_ATTRIBUTES_INTERNAL 36
138 #define FILE_HEADER_ATTRIBUTES_EXTERNAL 38
139 #define FILE_HEADER_OFFSET 42
140 #define SIZE_FILE_HEADER 46
141
142 /* Not mandatory, but recommended by specification. */
143 #define DATA_DESCRIPTOR_SIGNATURE 0
144 #define DATA_DESCRIPTOR_CRC32 4
145 #define DATA_DESCRIPTOR_COMPRESSED_SIZE 8
146 #define DATA_DESCRIPTOR_UNCOMPRESSED_SIZE 12
147 #define SIZE_DATA_DESCRIPTOR 16
148
149 #define EXTRA_DATA_LOCAL_TIME_ID 0
150 #define EXTRA_DATA_LOCAL_TIME_SIZE 2
151 #define EXTRA_DATA_LOCAL_TIME_FLAG 4
152 #define EXTRA_DATA_LOCAL_MTIME 5
153 #define EXTRA_DATA_LOCAL_ATIME 9
154 #define EXTRA_DATA_LOCAL_CTIME 13
155 #define EXTRA_DATA_LOCAL_UNIX_ID 17
156 #define EXTRA_DATA_LOCAL_UNIX_SIZE 19
157 #define EXTRA_DATA_LOCAL_UNIX_VERSION 21
158 #define EXTRA_DATA_LOCAL_UNIX_UID_SIZE 22
159 #define EXTRA_DATA_LOCAL_UNIX_UID 23
160 #define EXTRA_DATA_LOCAL_UNIX_GID_SIZE 27
161 #define EXTRA_DATA_LOCAL_UNIX_GID 28
162 #define SIZE_EXTRA_DATA_LOCAL 32
163
164 #define EXTRA_DATA_CENTRAL_TIME_ID 0
165 #define EXTRA_DATA_CENTRAL_TIME_SIZE 2
166 #define EXTRA_DATA_CENTRAL_TIME_FLAG 4
167 #define EXTRA_DATA_CENTRAL_MTIME 5
168 #define EXTRA_DATA_CENTRAL_UNIX_ID 9
169 #define EXTRA_DATA_CENTRAL_UNIX_SIZE 11
170 #define SIZE_EXTRA_DATA_CENTRAL 13
171
172 #define CENTRAL_DIRECTORY_END_SIGNATURE 0
173 #define CENTRAL_DIRECTORY_END_DISK 4
174 #define CENTRAL_DIRECTORY_END_START_DISK 6
175 #define CENTRAL_DIRECTORY_END_ENTRIES_DISK 8
176 #define CENTRAL_DIRECTORY_END_ENTRIES 10
177 #define CENTRAL_DIRECTORY_END_SIZE 12
178 #define CENTRAL_DIRECTORY_END_OFFSET 16
179 #define CENTRAL_DIRECTORY_END_COMMENT_LENGTH 20
180 #define SIZE_CENTRAL_DIRECTORY_END 22
181
182 struct zip_file_header_link {
183 struct zip_file_header_link *next;
184 struct archive_entry *entry;
185 int64_t offset;
186 unsigned long crc32;
187 int64_t compressed_size;
188 enum compression compression;
189 int flags;
190 };
191
192 struct zip {
193 uint8_t data_descriptor[SIZE_DATA_DESCRIPTOR];
194 struct zip_file_header_link *central_directory;
195 struct zip_file_header_link *central_directory_end;
196 int64_t offset;
197 int64_t written_bytes;
198 int64_t remaining_data_bytes;
199 enum compression compression;
200 int flags;
201 struct archive_string_conv *opt_sconv;
202 struct archive_string_conv *sconv_default;
203 int init_default_conversion;
204
205 #ifdef HAVE_ZLIB_H
206 z_stream stream;
207 size_t len_buf;
208 unsigned char *buf;
209 #endif
210 };
211
212 static int
archive_write_zip_options(struct archive_write * a,const char * key,const char * val)213 archive_write_zip_options(struct archive_write *a, const char *key,
214 const char *val)
215 {
216 struct zip *zip = a->format_data;
217 int ret = ARCHIVE_FAILED;
218
219 if (strcmp(key, "compression") == 0) {
220 if (val == NULL || val[0] == 0) {
221 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
222 "%s: compression option needs a compression name",
223 a->format_name);
224 } else if (strcmp(val, "deflate") == 0) {
225 #ifdef HAVE_ZLIB_H
226 zip->compression = COMPRESSION_DEFLATE;
227 ret = ARCHIVE_OK;
228 #else
229 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
230 "deflate compression not supported");
231 #endif
232 } else if (strcmp(val, "store") == 0) {
233 zip->compression = COMPRESSION_STORE;
234 ret = ARCHIVE_OK;
235 }
236 return (ret);
237 } else if (strcmp(key, "hdrcharset") == 0) {
238 if (val == NULL || val[0] == 0) {
239 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
240 "%s: hdrcharset option needs a character-set name",
241 a->format_name);
242 } else {
243 zip->opt_sconv = archive_string_conversion_to_charset(
244 &a->archive, val, 0);
245 if (zip->opt_sconv != NULL)
246 ret = ARCHIVE_OK;
247 else
248 ret = ARCHIVE_FATAL;
249 }
250 return (ret);
251 }
252
253 /* Note: The "warn" return is just to inform the options
254 * supervisor that we didn't handle it. It will generate
255 * a suitable error if no one used this option. */
256 return (ARCHIVE_WARN);
257 }
258
259 int
archive_write_zip_set_compression_deflate(struct archive * _a)260 archive_write_zip_set_compression_deflate(struct archive *_a)
261 {
262 struct archive_write *a = (struct archive_write *)_a;
263 int ret = ARCHIVE_FAILED;
264
265 archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
266 ARCHIVE_STATE_NEW | ARCHIVE_STATE_HEADER,
267 "archive_write_zip_set_compression_deflate");
268 if (a->archive.archive_format != ARCHIVE_FORMAT_ZIP) {
269 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
270 "Can only use archive_write_zip_set_compression_deflate"
271 " with zip format");
272 ret = ARCHIVE_FATAL;
273 } else {
274 #ifdef HAVE_ZLIB_H
275 struct zip *zip = a->format_data;
276 zip->compression = COMPRESSION_DEFLATE;
277 ret = ARCHIVE_OK;
278 #else
279 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
280 "deflate compression not supported");
281 #endif
282 }
283 return (ret);
284 }
285
286 int
archive_write_zip_set_compression_store(struct archive * _a)287 archive_write_zip_set_compression_store(struct archive *_a)
288 {
289 struct archive_write *a = (struct archive_write *)_a;
290 struct zip *zip = a->format_data;
291 int ret = ARCHIVE_FAILED;
292
293 archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
294 ARCHIVE_STATE_NEW | ARCHIVE_STATE_HEADER,
295 "archive_write_zip_set_compression_deflate");
296 if (a->archive.archive_format != ARCHIVE_FORMAT_ZIP) {
297 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
298 "Can only use archive_write_zip_set_compression_store"
299 " with zip format");
300 ret = ARCHIVE_FATAL;
301 } else {
302 zip->compression = COMPRESSION_STORE;
303 ret = ARCHIVE_OK;
304 }
305 return (ret);
306 }
307
308 int
archive_write_set_format_zip(struct archive * _a)309 archive_write_set_format_zip(struct archive *_a)
310 {
311 struct archive_write *a = (struct archive_write *)_a;
312 struct zip *zip;
313
314 archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
315 ARCHIVE_STATE_NEW, "archive_write_set_format_zip");
316
317 /* If another format was already registered, unregister it. */
318 if (a->format_free != NULL)
319 (a->format_free)(a);
320
321 zip = (struct zip *) calloc(1, sizeof(*zip));
322 if (zip == NULL) {
323 archive_set_error(&a->archive, ENOMEM,
324 "Can't allocate zip data");
325 return (ARCHIVE_FATAL);
326 }
327 zip->central_directory = NULL;
328 zip->central_directory_end = NULL;
329 zip->offset = 0;
330 zip->written_bytes = 0;
331 zip->remaining_data_bytes = 0;
332
333 #ifdef HAVE_ZLIB_H
334 zip->compression = COMPRESSION_DEFLATE;
335 zip->len_buf = 65536;
336 zip->buf = malloc(zip->len_buf);
337 if (zip->buf == NULL) {
338 free(zip);
339 archive_set_error(&a->archive, ENOMEM,
340 "Can't allocate compression buffer");
341 return (ARCHIVE_FATAL);
342 }
343 #else
344 zip->compression = COMPRESSION_STORE;
345 #endif
346
347 a->format_data = zip;
348 a->format_name = "zip";
349 a->format_options = archive_write_zip_options;
350 a->format_write_header = archive_write_zip_header;
351 a->format_write_data = archive_write_zip_data;
352 a->format_finish_entry = archive_write_zip_finish_entry;
353 a->format_close = archive_write_zip_close;
354 a->format_free = archive_write_zip_free;
355 a->archive.archive_format = ARCHIVE_FORMAT_ZIP;
356 a->archive.archive_format_name = "ZIP";
357
358 archive_le32enc(&zip->data_descriptor[DATA_DESCRIPTOR_SIGNATURE],
359 ZIP_SIGNATURE_DATA_DESCRIPTOR);
360
361 return (ARCHIVE_OK);
362 }
363
364 static int
is_all_ascii(const char * p)365 is_all_ascii(const char *p)
366 {
367 const unsigned char *pp = (const unsigned char *)p;
368
369 while (*pp) {
370 if (*pp++ > 127)
371 return (0);
372 }
373 return (1);
374 }
375
376 static int
archive_write_zip_header(struct archive_write * a,struct archive_entry * entry)377 archive_write_zip_header(struct archive_write *a, struct archive_entry *entry)
378 {
379 struct zip *zip;
380 uint8_t h[SIZE_LOCAL_FILE_HEADER];
381 uint8_t e[SIZE_EXTRA_DATA_LOCAL];
382 uint8_t *d;
383 struct zip_file_header_link *l;
384 struct archive_string_conv *sconv;
385 int ret, ret2 = ARCHIVE_OK;
386 int64_t size;
387 mode_t type;
388
389 /* Entries other than a regular file or a folder are skipped. */
390 type = archive_entry_filetype(entry);
391 if (type != AE_IFREG && type != AE_IFDIR && type != AE_IFLNK) {
392 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
393 "Filetype not supported");
394 return ARCHIVE_FAILED;
395 };
396
397 /* Directory entries should have a size of 0. */
398 if (type == AE_IFDIR)
399 archive_entry_set_size(entry, 0);
400
401 zip = a->format_data;
402 /* Setup default conversion. */
403 if (zip->opt_sconv == NULL && !zip->init_default_conversion) {
404 zip->sconv_default =
405 archive_string_default_conversion_for_write(&(a->archive));
406 zip->init_default_conversion = 1;
407 }
408
409 if (zip->flags == 0) {
410 /* Initialize the general purpose flags. */
411 zip->flags = ZIP_FLAGS;
412 if (zip->opt_sconv != NULL) {
413 if (strcmp(archive_string_conversion_charset_name(
414 zip->opt_sconv), "UTF-8") == 0)
415 zip->flags |= ZIP_FLAGS_UTF8_NAME;
416 #if HAVE_NL_LANGINFO
417 } else if (strcmp(nl_langinfo(CODESET), "UTF-8") == 0) {
418 zip->flags |= ZIP_FLAGS_UTF8_NAME;
419 #endif
420 }
421 }
422 d = zip->data_descriptor;
423 size = archive_entry_size(entry);
424 zip->remaining_data_bytes = size;
425
426 /* Append archive entry to the central directory data. */
427 l = (struct zip_file_header_link *) malloc(sizeof(*l));
428 if (l == NULL) {
429 archive_set_error(&a->archive, ENOMEM,
430 "Can't allocate zip header data");
431 return (ARCHIVE_FATAL);
432 }
433 #if defined(_WIN32) && !defined(__CYGWIN__)
434 /* Make sure the path separators in pahtname, hardlink and symlink
435 * are all slash '/', not the Windows path separator '\'. */
436 l->entry = __la_win_entry_in_posix_pathseparator(entry);
437 if (l->entry == entry)
438 l->entry = archive_entry_clone(entry);
439 #else
440 l->entry = archive_entry_clone(entry);
441 #endif
442 if (l->entry == NULL) {
443 archive_set_error(&a->archive, ENOMEM,
444 "Can't allocate zip header data");
445 free(l);
446 return (ARCHIVE_FATAL);
447 }
448 l->flags = zip->flags;
449 if (zip->opt_sconv != NULL)
450 sconv = zip->opt_sconv;
451 else
452 sconv = zip->sconv_default;
453 if (sconv != NULL) {
454 const char *p;
455 size_t len;
456
457 if (archive_entry_pathname_l(entry, &p, &len, sconv) != 0) {
458 if (errno == ENOMEM) {
459 archive_entry_free(l->entry);
460 free(l);
461 archive_set_error(&a->archive, ENOMEM,
462 "Can't allocate memory for Pathname");
463 return (ARCHIVE_FATAL);
464 }
465 archive_set_error(&a->archive,
466 ARCHIVE_ERRNO_FILE_FORMAT,
467 "Can't translate Pathname '%s' to %s",
468 archive_entry_pathname(entry),
469 archive_string_conversion_charset_name(sconv));
470 ret2 = ARCHIVE_WARN;
471 }
472 if (len > 0)
473 archive_entry_set_pathname(l->entry, p);
474
475 /*
476 * Although there is no character-set regulation for Symlink,
477 * it is suitable to convert a character-set of Symlinke to
478 * what those of the Pathname has been converted to.
479 */
480 if (type == AE_IFLNK) {
481 if (archive_entry_symlink_l(entry, &p, &len, sconv)) {
482 if (errno == ENOMEM) {
483 archive_entry_free(l->entry);
484 free(l);
485 archive_set_error(&a->archive, ENOMEM,
486 "Can't allocate memory "
487 " for Symlink");
488 return (ARCHIVE_FATAL);
489 }
490 /*
491 * Even if the strng conversion failed,
492 * we should not report the error since
493 * thre is no regulation for.
494 */
495 } else if (len > 0)
496 archive_entry_set_symlink(l->entry, p);
497 }
498 }
499 /* If all characters in a filename are ASCII, Reset UTF-8 Name flag. */
500 if ((l->flags & ZIP_FLAGS_UTF8_NAME) != 0 &&
501 is_all_ascii(archive_entry_pathname(l->entry)))
502 l->flags &= ~ZIP_FLAGS_UTF8_NAME;
503
504 /* Initialize the CRC variable and potentially the local crc32(). */
505 l->crc32 = crc32(0, NULL, 0);
506 if (type == AE_IFLNK) {
507 const char *p = archive_entry_symlink(l->entry);
508 if (p != NULL)
509 size = strlen(p);
510 else
511 size = 0;
512 zip->remaining_data_bytes = 0;
513 archive_entry_set_size(l->entry, size);
514 l->compression = COMPRESSION_STORE;
515 l->compressed_size = size;
516 } else {
517 l->compression = zip->compression;
518 l->compressed_size = 0;
519 }
520 l->next = NULL;
521 if (zip->central_directory == NULL) {
522 zip->central_directory = l;
523 } else {
524 zip->central_directory_end->next = l;
525 }
526 zip->central_directory_end = l;
527
528 /* Store the offset of this header for later use in central
529 * directory. */
530 l->offset = zip->written_bytes;
531
532 memset(h, 0, sizeof(h));
533 archive_le32enc(&h[LOCAL_FILE_HEADER_SIGNATURE],
534 ZIP_SIGNATURE_LOCAL_FILE_HEADER);
535 archive_le16enc(&h[LOCAL_FILE_HEADER_VERSION], ZIP_VERSION_EXTRACT);
536 archive_le16enc(&h[LOCAL_FILE_HEADER_FLAGS], l->flags);
537 archive_le16enc(&h[LOCAL_FILE_HEADER_COMPRESSION], l->compression);
538 archive_le32enc(&h[LOCAL_FILE_HEADER_TIMEDATE],
539 dos_time(archive_entry_mtime(entry)));
540 archive_le16enc(&h[LOCAL_FILE_HEADER_FILENAME_LENGTH],
541 (uint16_t)path_length(l->entry));
542
543 switch (l->compression) {
544 case COMPRESSION_STORE:
545 /* Setting compressed and uncompressed sizes even when
546 * specification says to set to zero when using data
547 * descriptors. Otherwise the end of the data for an
548 * entry is rather difficult to find. */
549 archive_le32enc(&h[LOCAL_FILE_HEADER_COMPRESSED_SIZE],
550 (uint32_t)size);
551 archive_le32enc(&h[LOCAL_FILE_HEADER_UNCOMPRESSED_SIZE],
552 (uint32_t)size);
553 break;
554 #ifdef HAVE_ZLIB_H
555 case COMPRESSION_DEFLATE:
556 archive_le32enc(&h[LOCAL_FILE_HEADER_UNCOMPRESSED_SIZE],
557 (uint32_t)size);
558
559 zip->stream.zalloc = Z_NULL;
560 zip->stream.zfree = Z_NULL;
561 zip->stream.opaque = Z_NULL;
562 zip->stream.next_out = zip->buf;
563 zip->stream.avail_out = (uInt)zip->len_buf;
564 if (deflateInit2(&zip->stream, Z_DEFAULT_COMPRESSION,
565 Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY) != Z_OK) {
566 archive_set_error(&a->archive, ENOMEM,
567 "Can't init deflate compressor");
568 return (ARCHIVE_FATAL);
569 }
570 break;
571 #endif
572 }
573
574 /* Formatting extra data. */
575 archive_le16enc(&h[LOCAL_FILE_HEADER_EXTRA_LENGTH], sizeof(e));
576 archive_le16enc(&e[EXTRA_DATA_LOCAL_TIME_ID],
577 ZIP_SIGNATURE_EXTRA_TIMESTAMP);
578 archive_le16enc(&e[EXTRA_DATA_LOCAL_TIME_SIZE], 1 + 4 * 3);
579 e[EXTRA_DATA_LOCAL_TIME_FLAG] = 0x07;
580 archive_le32enc(&e[EXTRA_DATA_LOCAL_MTIME],
581 (uint32_t)archive_entry_mtime(entry));
582 archive_le32enc(&e[EXTRA_DATA_LOCAL_ATIME],
583 (uint32_t)archive_entry_atime(entry));
584 archive_le32enc(&e[EXTRA_DATA_LOCAL_CTIME],
585 (uint32_t)archive_entry_ctime(entry));
586
587 archive_le16enc(&e[EXTRA_DATA_LOCAL_UNIX_ID],
588 ZIP_SIGNATURE_EXTRA_NEW_UNIX);
589 archive_le16enc(&e[EXTRA_DATA_LOCAL_UNIX_SIZE], 1 + (1 + 4) * 2);
590 e[EXTRA_DATA_LOCAL_UNIX_VERSION] = 1;
591 e[EXTRA_DATA_LOCAL_UNIX_UID_SIZE] = 4;
592 archive_le32enc(&e[EXTRA_DATA_LOCAL_UNIX_UID],
593 (uint32_t)archive_entry_uid(entry));
594 e[EXTRA_DATA_LOCAL_UNIX_GID_SIZE] = 4;
595 archive_le32enc(&e[EXTRA_DATA_LOCAL_UNIX_GID],
596 (uint32_t)archive_entry_gid(entry));
597
598 archive_le32enc(&d[DATA_DESCRIPTOR_UNCOMPRESSED_SIZE],
599 (uint32_t)size);
600
601 ret = __archive_write_output(a, h, sizeof(h));
602 if (ret != ARCHIVE_OK)
603 return (ARCHIVE_FATAL);
604 zip->written_bytes += sizeof(h);
605
606 ret = write_path(l->entry, a);
607 if (ret <= ARCHIVE_OK)
608 return (ARCHIVE_FATAL);
609 zip->written_bytes += ret;
610
611 ret = __archive_write_output(a, e, sizeof(e));
612 if (ret != ARCHIVE_OK)
613 return (ARCHIVE_FATAL);
614 zip->written_bytes += sizeof(e);
615
616 if (type == AE_IFLNK) {
617 const unsigned char *p;
618
619 p = (const unsigned char *)archive_entry_symlink(l->entry);
620 ret = __archive_write_output(a, p, (size_t)size);
621 if (ret != ARCHIVE_OK)
622 return (ARCHIVE_FATAL);
623 zip->written_bytes += size;
624 l->crc32 = crc32(l->crc32, p, (unsigned)size);
625 }
626
627 if (ret2 != ARCHIVE_OK)
628 return (ret2);
629 return (ARCHIVE_OK);
630 }
631
632 static ssize_t
archive_write_zip_data(struct archive_write * a,const void * buff,size_t s)633 archive_write_zip_data(struct archive_write *a, const void *buff, size_t s)
634 {
635 int ret;
636 struct zip *zip = a->format_data;
637 struct zip_file_header_link *l = zip->central_directory_end;
638
639 if ((int64_t)s > zip->remaining_data_bytes)
640 s = (size_t)zip->remaining_data_bytes;
641
642 if (s == 0) return 0;
643
644 switch (l->compression) {
645 case COMPRESSION_STORE:
646 ret = __archive_write_output(a, buff, s);
647 if (ret != ARCHIVE_OK) return (ret);
648 zip->written_bytes += s;
649 zip->remaining_data_bytes -= s;
650 l->compressed_size += s;
651 l->crc32 = crc32(l->crc32, buff, (unsigned)s);
652 return (s);
653 #if HAVE_ZLIB_H
654 case COMPRESSION_DEFLATE:
655 zip->stream.next_in = (unsigned char*)(uintptr_t)buff;
656 zip->stream.avail_in = (uInt)s;
657 do {
658 ret = deflate(&zip->stream, Z_NO_FLUSH);
659 if (ret == Z_STREAM_ERROR)
660 return (ARCHIVE_FATAL);
661 if (zip->stream.avail_out == 0) {
662 ret = __archive_write_output(a, zip->buf,
663 zip->len_buf);
664 if (ret != ARCHIVE_OK)
665 return (ret);
666 l->compressed_size += zip->len_buf;
667 zip->written_bytes += zip->len_buf;
668 zip->stream.next_out = zip->buf;
669 zip->stream.avail_out = (uInt)zip->len_buf;
670 }
671 } while (zip->stream.avail_in != 0);
672 zip->remaining_data_bytes -= s;
673 /* If we have it, use zlib's fast crc32() */
674 l->crc32 = crc32(l->crc32, buff, (uInt)s);
675 return (s);
676 #endif
677
678 default:
679 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
680 "Invalid ZIP compression type");
681 return ARCHIVE_FATAL;
682 }
683 }
684
685 static int
archive_write_zip_finish_entry(struct archive_write * a)686 archive_write_zip_finish_entry(struct archive_write *a)
687 {
688 /* Write the data descripter after file data has been written. */
689 int ret;
690 struct zip *zip = a->format_data;
691 uint8_t *d = zip->data_descriptor;
692 struct zip_file_header_link *l = zip->central_directory_end;
693 #if HAVE_ZLIB_H
694 size_t reminder;
695 #endif
696
697 switch(l->compression) {
698 case COMPRESSION_STORE:
699 break;
700 #if HAVE_ZLIB_H
701 case COMPRESSION_DEFLATE:
702 for (;;) {
703 ret = deflate(&zip->stream, Z_FINISH);
704 if (ret == Z_STREAM_ERROR)
705 return (ARCHIVE_FATAL);
706 reminder = zip->len_buf - zip->stream.avail_out;
707 ret = __archive_write_output(a, zip->buf, reminder);
708 if (ret != ARCHIVE_OK)
709 return (ret);
710 l->compressed_size += reminder;
711 zip->written_bytes += reminder;
712 zip->stream.next_out = zip->buf;
713 if (zip->stream.avail_out != 0)
714 break;
715 zip->stream.avail_out = (uInt)zip->len_buf;
716 }
717 deflateEnd(&zip->stream);
718 break;
719 #endif
720 }
721
722 archive_le32enc(&d[DATA_DESCRIPTOR_CRC32], l->crc32);
723 archive_le32enc(&d[DATA_DESCRIPTOR_COMPRESSED_SIZE],
724 (uint32_t)l->compressed_size);
725 ret = __archive_write_output(a, d, SIZE_DATA_DESCRIPTOR);
726 if (ret != ARCHIVE_OK)
727 return (ARCHIVE_FATAL);
728 zip->written_bytes += SIZE_DATA_DESCRIPTOR;
729 return (ARCHIVE_OK);
730 }
731
732 static int
archive_write_zip_close(struct archive_write * a)733 archive_write_zip_close(struct archive_write *a)
734 {
735 struct zip *zip;
736 struct zip_file_header_link *l;
737 uint8_t h[SIZE_FILE_HEADER];
738 uint8_t end[SIZE_CENTRAL_DIRECTORY_END];
739 uint8_t e[SIZE_EXTRA_DATA_CENTRAL];
740 int64_t offset_start, offset_end;
741 int entries;
742 int ret;
743
744 zip = a->format_data;
745 l = zip->central_directory;
746
747 /*
748 * Formatting central directory file header fields that are
749 * fixed for all entries.
750 * Fields not used (and therefor 0) are:
751 *
752 * - comment_length
753 * - disk_number
754 * - attributes_internal
755 */
756 memset(h, 0, sizeof(h));
757 archive_le32enc(&h[FILE_HEADER_SIGNATURE], ZIP_SIGNATURE_FILE_HEADER);
758 archive_le16enc(&h[FILE_HEADER_VERSION_BY], ZIP_VERSION_BY);
759 archive_le16enc(&h[FILE_HEADER_VERSION_EXTRACT], ZIP_VERSION_EXTRACT);
760
761 entries = 0;
762 offset_start = zip->written_bytes;
763
764 /* Formatting individual header fields per entry and
765 * writing each entry. */
766 while (l != NULL) {
767 archive_le16enc(&h[FILE_HEADER_FLAGS], l->flags);
768 archive_le16enc(&h[FILE_HEADER_COMPRESSION], l->compression);
769 archive_le32enc(&h[FILE_HEADER_TIMEDATE],
770 dos_time(archive_entry_mtime(l->entry)));
771 archive_le32enc(&h[FILE_HEADER_CRC32], l->crc32);
772 archive_le32enc(&h[FILE_HEADER_COMPRESSED_SIZE],
773 (uint32_t)l->compressed_size);
774 archive_le32enc(&h[FILE_HEADER_UNCOMPRESSED_SIZE],
775 (uint32_t)archive_entry_size(l->entry));
776 archive_le16enc(&h[FILE_HEADER_FILENAME_LENGTH],
777 (uint16_t)path_length(l->entry));
778 archive_le16enc(&h[FILE_HEADER_EXTRA_LENGTH], sizeof(e));
779 archive_le16enc(&h[FILE_HEADER_ATTRIBUTES_EXTERNAL+2],
780 archive_entry_mode(l->entry));
781 archive_le32enc(&h[FILE_HEADER_OFFSET], (uint32_t)l->offset);
782
783 /* Formatting extra data. */
784 archive_le16enc(&e[EXTRA_DATA_CENTRAL_TIME_ID],
785 ZIP_SIGNATURE_EXTRA_TIMESTAMP);
786 archive_le16enc(&e[EXTRA_DATA_CENTRAL_TIME_SIZE], 1 + 4);
787 e[EXTRA_DATA_CENTRAL_TIME_FLAG] = 0x07;
788 archive_le32enc(&e[EXTRA_DATA_CENTRAL_MTIME],
789 (uint32_t)archive_entry_mtime(l->entry));
790 archive_le16enc(&e[EXTRA_DATA_CENTRAL_UNIX_ID],
791 ZIP_SIGNATURE_EXTRA_NEW_UNIX);
792 archive_le16enc(&e[EXTRA_DATA_CENTRAL_UNIX_SIZE], 0x0000);
793
794 ret = __archive_write_output(a, h, sizeof(h));
795 if (ret != ARCHIVE_OK)
796 return (ARCHIVE_FATAL);
797 zip->written_bytes += sizeof(h);
798
799 ret = write_path(l->entry, a);
800 if (ret <= ARCHIVE_OK)
801 return (ARCHIVE_FATAL);
802 zip->written_bytes += ret;
803
804 ret = __archive_write_output(a, e, sizeof(e));
805 if (ret != ARCHIVE_OK)
806 return (ARCHIVE_FATAL);
807 zip->written_bytes += sizeof(e);
808
809 l = l->next;
810 entries++;
811 }
812 offset_end = zip->written_bytes;
813
814 /* Formatting end of central directory. */
815 memset(end, 0, sizeof(end));
816 archive_le32enc(&end[CENTRAL_DIRECTORY_END_SIGNATURE],
817 ZIP_SIGNATURE_CENTRAL_DIRECTORY_END);
818 archive_le16enc(&end[CENTRAL_DIRECTORY_END_ENTRIES_DISK], entries);
819 archive_le16enc(&end[CENTRAL_DIRECTORY_END_ENTRIES], entries);
820 archive_le32enc(&end[CENTRAL_DIRECTORY_END_SIZE],
821 (uint32_t)(offset_end - offset_start));
822 archive_le32enc(&end[CENTRAL_DIRECTORY_END_OFFSET],
823 (uint32_t)offset_start);
824
825 /* Writing end of central directory. */
826 ret = __archive_write_output(a, end, sizeof(end));
827 if (ret != ARCHIVE_OK)
828 return (ARCHIVE_FATAL);
829 zip->written_bytes += sizeof(end);
830 return (ARCHIVE_OK);
831 }
832
833 static int
archive_write_zip_free(struct archive_write * a)834 archive_write_zip_free(struct archive_write *a)
835 {
836 struct zip *zip;
837 struct zip_file_header_link *l;
838
839 zip = a->format_data;
840 while (zip->central_directory != NULL) {
841 l = zip->central_directory;
842 zip->central_directory = l->next;
843 archive_entry_free(l->entry);
844 free(l);
845 }
846 #ifdef HAVE_ZLIB_H
847 free(zip->buf);
848 #endif
849 free(zip);
850 a->format_data = NULL;
851 return (ARCHIVE_OK);
852 }
853
854 /* Convert into MSDOS-style date/time. */
855 static unsigned int
dos_time(const time_t unix_time)856 dos_time(const time_t unix_time)
857 {
858 struct tm *t;
859 unsigned int dt;
860
861 /* This will not preserve time when creating/extracting the archive
862 * on two systems with different time zones. */
863 t = localtime(&unix_time);
864
865 /* MSDOS-style date/time is only between 1980-01-01 and 2107-12-31 */
866 if (t->tm_year < 1980 - 1900)
867 /* Set minimum date/time '1980-01-01 00:00:00'. */
868 dt = 0x00210000U;
869 else if (t->tm_year > 2107 - 1900)
870 /* Set maximum date/time '2107-12-31 23:59:58'. */
871 dt = 0xff9fbf7dU;
872 else {
873 dt = 0;
874 dt += ((t->tm_year - 80) & 0x7f) << 9;
875 dt += ((t->tm_mon + 1) & 0x0f) << 5;
876 dt += (t->tm_mday & 0x1f);
877 dt <<= 16;
878 dt += (t->tm_hour & 0x1f) << 11;
879 dt += (t->tm_min & 0x3f) << 5;
880 dt += (t->tm_sec & 0x3e) >> 1; /* Only counting every 2 seconds. */
881 }
882 return dt;
883 }
884
885 static size_t
path_length(struct archive_entry * entry)886 path_length(struct archive_entry *entry)
887 {
888 mode_t type;
889 const char *path;
890
891 type = archive_entry_filetype(entry);
892 path = archive_entry_pathname(entry);
893
894 if (path == NULL)
895 return (0);
896 if (type == AE_IFDIR &&
897 (path[0] == '\0' || path[strlen(path) - 1] != '/')) {
898 return strlen(path) + 1;
899 } else {
900 return strlen(path);
901 }
902 }
903
904 static int
write_path(struct archive_entry * entry,struct archive_write * archive)905 write_path(struct archive_entry *entry, struct archive_write *archive)
906 {
907 int ret;
908 const char *path;
909 mode_t type;
910 size_t written_bytes;
911
912 path = archive_entry_pathname(entry);
913 type = archive_entry_filetype(entry);
914 written_bytes = 0;
915
916 ret = __archive_write_output(archive, path, strlen(path));
917 if (ret != ARCHIVE_OK)
918 return (ARCHIVE_FATAL);
919 written_bytes += strlen(path);
920
921 /* Folders are recognized by a traling slash. */
922 if ((type == AE_IFDIR) & (path[strlen(path) - 1] != '/')) {
923 ret = __archive_write_output(archive, "/", 1);
924 if (ret != ARCHIVE_OK)
925 return (ARCHIVE_FATAL);
926 written_bytes += 1;
927 }
928
929 return ((int)written_bytes);
930 }
931