| /*- |
| * Copyright (c) 2008 Anselm Strauss |
| * Copyright (c) 2009 Joerg Sonnenberger |
| * Copyright (c) 2011-2012 Michihiro NAKAJIMA |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| /* |
| * Development supported by Google Summer of Code 2008. |
| */ |
| |
| /* |
| * The current implementation is very limited: |
| * |
| * - No encryption support. |
| * - No ZIP64 support. |
| * - No support for splitting and spanning. |
| * - Only supports regular file and folder entries. |
| * |
| * Note that generally data in ZIP files is little-endian encoded, |
| * with some exceptions. |
| * |
| * TODO: Since Libarchive is generally 64bit oriented, but this implementation |
| * does not yet support sizes exceeding 32bit, it is highly fragile for |
| * big archives. This should change when ZIP64 is finally implemented, otherwise |
| * some serious checking has to be done. |
| * |
| */ |
| |
| #include "archive_platform.h" |
| __FBSDID("$FreeBSD: head/lib/libarchive/archive_write_set_format_zip.c 201168 2009-12-29 06:15:32Z kientzle $"); |
| |
| #ifdef HAVE_ERRNO_H |
| #include <errno.h> |
| #endif |
| #ifdef HAVE_LANGINFO_H |
| #include <langinfo.h> |
| #endif |
| #ifdef HAVE_STDLIB_H |
| #include <stdlib.h> |
| #endif |
| #ifdef HAVE_STRING_H |
| #include <string.h> |
| #endif |
| #ifdef HAVE_ZLIB_H |
| #include <zlib.h> |
| #endif |
| |
| #include "archive.h" |
| #include "archive_endian.h" |
| #include "archive_entry.h" |
| #include "archive_entry_locale.h" |
| #include "archive_private.h" |
| #include "archive_write_private.h" |
| |
| #ifndef HAVE_ZLIB_H |
| #include "archive_crc32.h" |
| #endif |
| |
| #define ZIP_SIGNATURE_LOCAL_FILE_HEADER 0x04034b50 |
| #define ZIP_SIGNATURE_DATA_DESCRIPTOR 0x08074b50 |
| #define ZIP_SIGNATURE_FILE_HEADER 0x02014b50 |
| #define ZIP_SIGNATURE_CENTRAL_DIRECTORY_END 0x06054b50 |
| #define ZIP_SIGNATURE_EXTRA_TIMESTAMP 0x5455 |
| #define ZIP_SIGNATURE_EXTRA_NEW_UNIX 0x7875 |
| #define ZIP_VERSION_EXTRACT 0x0014 /* ZIP version 2.0 is needed. */ |
| #define ZIP_VERSION_BY 0x0314 /* Made by UNIX, using ZIP version 2.0. */ |
| #define ZIP_FLAGS 0x08 /* Flagging bit 3 (count from 0) for using data descriptor. */ |
| #define ZIP_FLAGS_UTF8_NAME (1 << 11) |
| |
| enum compression { |
| COMPRESSION_STORE = 0 |
| #ifdef HAVE_ZLIB_H |
| , |
| COMPRESSION_DEFLATE = 8 |
| #endif |
| }; |
| |
| static ssize_t archive_write_zip_data(struct archive_write *, |
| const void *buff, size_t s); |
| static int archive_write_zip_close(struct archive_write *); |
| static int archive_write_zip_free(struct archive_write *); |
| static int archive_write_zip_finish_entry(struct archive_write *); |
| static int archive_write_zip_header(struct archive_write *, |
| struct archive_entry *); |
| static int archive_write_zip_options(struct archive_write *, |
| const char *, const char *); |
| static unsigned int dos_time(const time_t); |
| static size_t path_length(struct archive_entry *); |
| static int write_path(struct archive_entry *, struct archive_write *); |
| |
| #define LOCAL_FILE_HEADER_SIGNATURE 0 |
| #define LOCAL_FILE_HEADER_VERSION 4 |
| #define LOCAL_FILE_HEADER_FLAGS 6 |
| #define LOCAL_FILE_HEADER_COMPRESSION 8 |
| #define LOCAL_FILE_HEADER_TIMEDATE 10 |
| #define LOCAL_FILE_HEADER_CRC32 14 |
| #define LOCAL_FILE_HEADER_COMPRESSED_SIZE 18 |
| #define LOCAL_FILE_HEADER_UNCOMPRESSED_SIZE 22 |
| #define LOCAL_FILE_HEADER_FILENAME_LENGTH 26 |
| #define LOCAL_FILE_HEADER_EXTRA_LENGTH 28 |
| #define SIZE_LOCAL_FILE_HEADER 30 |
| |
| #define FILE_HEADER_SIGNATURE 0 |
| #define FILE_HEADER_VERSION_BY 4 |
| #define FILE_HEADER_VERSION_EXTRACT 6 |
| #define FILE_HEADER_FLAGS 8 |
| #define FILE_HEADER_COMPRESSION 10 |
| #define FILE_HEADER_TIMEDATE 12 |
| #define FILE_HEADER_CRC32 16 |
| #define FILE_HEADER_COMPRESSED_SIZE 20 |
| #define FILE_HEADER_UNCOMPRESSED_SIZE 24 |
| #define FILE_HEADER_FILENAME_LENGTH 28 |
| #define FILE_HEADER_EXTRA_LENGTH 30 |
| #define FILE_HEADER_COMMENT_LENGTH 32 |
| #define FILE_HEADER_DISK_NUMBER 34 |
| #define FILE_HEADER_ATTRIBUTES_INTERNAL 36 |
| #define FILE_HEADER_ATTRIBUTES_EXTERNAL 38 |
| #define FILE_HEADER_OFFSET 42 |
| #define SIZE_FILE_HEADER 46 |
| |
| /* Not mandatory, but recommended by specification. */ |
| #define DATA_DESCRIPTOR_SIGNATURE 0 |
| #define DATA_DESCRIPTOR_CRC32 4 |
| #define DATA_DESCRIPTOR_COMPRESSED_SIZE 8 |
| #define DATA_DESCRIPTOR_UNCOMPRESSED_SIZE 12 |
| #define SIZE_DATA_DESCRIPTOR 16 |
| |
| #define EXTRA_DATA_LOCAL_TIME_ID 0 |
| #define EXTRA_DATA_LOCAL_TIME_SIZE 2 |
| #define EXTRA_DATA_LOCAL_TIME_FLAG 4 |
| #define EXTRA_DATA_LOCAL_MTIME 5 |
| #define EXTRA_DATA_LOCAL_ATIME 9 |
| #define EXTRA_DATA_LOCAL_CTIME 13 |
| #define EXTRA_DATA_LOCAL_UNIX_ID 17 |
| #define EXTRA_DATA_LOCAL_UNIX_SIZE 19 |
| #define EXTRA_DATA_LOCAL_UNIX_VERSION 21 |
| #define EXTRA_DATA_LOCAL_UNIX_UID_SIZE 22 |
| #define EXTRA_DATA_LOCAL_UNIX_UID 23 |
| #define EXTRA_DATA_LOCAL_UNIX_GID_SIZE 27 |
| #define EXTRA_DATA_LOCAL_UNIX_GID 28 |
| #define SIZE_EXTRA_DATA_LOCAL 32 |
| |
| #define EXTRA_DATA_CENTRAL_TIME_ID 0 |
| #define EXTRA_DATA_CENTRAL_TIME_SIZE 2 |
| #define EXTRA_DATA_CENTRAL_TIME_FLAG 4 |
| #define EXTRA_DATA_CENTRAL_MTIME 5 |
| #define EXTRA_DATA_CENTRAL_UNIX_ID 9 |
| #define EXTRA_DATA_CENTRAL_UNIX_SIZE 11 |
| #define SIZE_EXTRA_DATA_CENTRAL 13 |
| |
| #define CENTRAL_DIRECTORY_END_SIGNATURE 0 |
| #define CENTRAL_DIRECTORY_END_DISK 4 |
| #define CENTRAL_DIRECTORY_END_START_DISK 6 |
| #define CENTRAL_DIRECTORY_END_ENTRIES_DISK 8 |
| #define CENTRAL_DIRECTORY_END_ENTRIES 10 |
| #define CENTRAL_DIRECTORY_END_SIZE 12 |
| #define CENTRAL_DIRECTORY_END_OFFSET 16 |
| #define CENTRAL_DIRECTORY_END_COMMENT_LENGTH 20 |
| #define SIZE_CENTRAL_DIRECTORY_END 22 |
| |
| struct zip_file_header_link { |
| struct zip_file_header_link *next; |
| struct archive_entry *entry; |
| int64_t offset; |
| unsigned long crc32; |
| int64_t compressed_size; |
| enum compression compression; |
| int flags; |
| }; |
| |
| struct zip { |
| uint8_t data_descriptor[SIZE_DATA_DESCRIPTOR]; |
| struct zip_file_header_link *central_directory; |
| struct zip_file_header_link *central_directory_end; |
| int64_t offset; |
| int64_t written_bytes; |
| int64_t remaining_data_bytes; |
| enum compression compression; |
| int flags; |
| struct archive_string_conv *opt_sconv; |
| struct archive_string_conv *sconv_default; |
| int init_default_conversion; |
| |
| #ifdef HAVE_ZLIB_H |
| z_stream stream; |
| size_t len_buf; |
| unsigned char *buf; |
| #endif |
| }; |
| |
| static int |
| archive_write_zip_options(struct archive_write *a, const char *key, |
| const char *val) |
| { |
| struct zip *zip = a->format_data; |
| int ret = ARCHIVE_FAILED; |
| |
| if (strcmp(key, "compression") == 0) { |
| if (val == NULL || val[0] == 0) { |
| archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, |
| "%s: compression option needs a compression name", |
| a->format_name); |
| } else if (strcmp(val, "deflate") == 0) { |
| #ifdef HAVE_ZLIB_H |
| zip->compression = COMPRESSION_DEFLATE; |
| ret = ARCHIVE_OK; |
| #else |
| archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, |
| "deflate compression not supported"); |
| #endif |
| } else if (strcmp(val, "store") == 0) { |
| zip->compression = COMPRESSION_STORE; |
| ret = ARCHIVE_OK; |
| } |
| return (ret); |
| } else if (strcmp(key, "hdrcharset") == 0) { |
| if (val == NULL || val[0] == 0) { |
| archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, |
| "%s: hdrcharset option needs a character-set name", |
| a->format_name); |
| } else { |
| zip->opt_sconv = archive_string_conversion_to_charset( |
| &a->archive, val, 0); |
| if (zip->opt_sconv != NULL) |
| ret = ARCHIVE_OK; |
| else |
| ret = ARCHIVE_FATAL; |
| } |
| return (ret); |
| } |
| |
| /* Note: The "warn" return is just to inform the options |
| * supervisor that we didn't handle it. It will generate |
| * a suitable error if no one used this option. */ |
| return (ARCHIVE_WARN); |
| } |
| |
| int |
| archive_write_set_format_zip(struct archive *_a) |
| { |
| struct archive_write *a = (struct archive_write *)_a; |
| struct zip *zip; |
| |
| archive_check_magic(_a, ARCHIVE_WRITE_MAGIC, |
| ARCHIVE_STATE_NEW, "archive_write_set_format_zip"); |
| |
| /* If another format was already registered, unregister it. */ |
| if (a->format_free != NULL) |
| (a->format_free)(a); |
| |
| zip = (struct zip *) calloc(1, sizeof(*zip)); |
| if (zip == NULL) { |
| archive_set_error(&a->archive, ENOMEM, |
| "Can't allocate zip data"); |
| return (ARCHIVE_FATAL); |
| } |
| zip->central_directory = NULL; |
| zip->central_directory_end = NULL; |
| zip->offset = 0; |
| zip->written_bytes = 0; |
| zip->remaining_data_bytes = 0; |
| |
| #ifdef HAVE_ZLIB_H |
| zip->compression = COMPRESSION_DEFLATE; |
| zip->len_buf = 65536; |
| zip->buf = malloc(zip->len_buf); |
| if (zip->buf == NULL) { |
| free(zip); |
| archive_set_error(&a->archive, ENOMEM, |
| "Can't allocate compression buffer"); |
| return (ARCHIVE_FATAL); |
| } |
| #else |
| zip->compression = COMPRESSION_STORE; |
| #endif |
| |
| a->format_data = zip; |
| a->format_name = "zip"; |
| a->format_options = archive_write_zip_options; |
| a->format_write_header = archive_write_zip_header; |
| a->format_write_data = archive_write_zip_data; |
| a->format_finish_entry = archive_write_zip_finish_entry; |
| a->format_close = archive_write_zip_close; |
| a->format_free = archive_write_zip_free; |
| a->archive.archive_format = ARCHIVE_FORMAT_ZIP; |
| a->archive.archive_format_name = "ZIP"; |
| |
| archive_le32enc(&zip->data_descriptor[DATA_DESCRIPTOR_SIGNATURE], |
| ZIP_SIGNATURE_DATA_DESCRIPTOR); |
| |
| return (ARCHIVE_OK); |
| } |
| |
| static int |
| is_all_ascii(const char *p) |
| { |
| const unsigned char *pp = (const unsigned char *)p; |
| |
| while (*pp) { |
| if (*pp++ > 127) |
| return (0); |
| } |
| return (1); |
| } |
| |
| static int |
| archive_write_zip_header(struct archive_write *a, struct archive_entry *entry) |
| { |
| struct zip *zip; |
| uint8_t h[SIZE_LOCAL_FILE_HEADER]; |
| uint8_t e[SIZE_EXTRA_DATA_LOCAL]; |
| uint8_t *d; |
| struct zip_file_header_link *l; |
| struct archive_string_conv *sconv; |
| int ret, ret2 = ARCHIVE_OK; |
| int64_t size; |
| mode_t type; |
| |
| /* Entries other than a regular file or a folder are skipped. */ |
| type = archive_entry_filetype(entry); |
| if (type != AE_IFREG && type != AE_IFDIR && type != AE_IFLNK) { |
| archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, |
| "Filetype not supported"); |
| return ARCHIVE_FAILED; |
| }; |
| |
| /* Directory entries should have a size of 0. */ |
| if (type == AE_IFDIR) |
| archive_entry_set_size(entry, 0); |
| |
| zip = a->format_data; |
| /* Setup default conversion. */ |
| if (zip->opt_sconv == NULL && !zip->init_default_conversion) { |
| zip->sconv_default = |
| archive_string_default_conversion_for_write(&(a->archive)); |
| zip->init_default_conversion = 1; |
| } |
| |
| if (zip->flags == 0) { |
| /* Initialize the general purpose flags. */ |
| zip->flags = ZIP_FLAGS; |
| if (zip->opt_sconv != NULL) { |
| if (strcmp(archive_string_conversion_charset_name( |
| zip->opt_sconv), "UTF-8") == 0) |
| zip->flags |= ZIP_FLAGS_UTF8_NAME; |
| #if HAVE_NL_LANGINFO |
| } else if (strcmp(nl_langinfo(CODESET), "UTF-8") == 0) { |
| zip->flags |= ZIP_FLAGS_UTF8_NAME; |
| #endif |
| } |
| } |
| d = zip->data_descriptor; |
| size = archive_entry_size(entry); |
| zip->remaining_data_bytes = size; |
| |
| /* Append archive entry to the central directory data. */ |
| l = (struct zip_file_header_link *) malloc(sizeof(*l)); |
| if (l == NULL) { |
| archive_set_error(&a->archive, ENOMEM, |
| "Can't allocate zip header data"); |
| return (ARCHIVE_FATAL); |
| } |
| #if defined(_WIN32) && !defined(__CYGWIN__) |
| /* Make sure the path separators in pahtname, hardlink and symlink |
| * are all slash '/', not the Windows path separator '\'. */ |
| l->entry = __la_win_entry_in_posix_pathseparator(entry); |
| if (l->entry == entry) |
| l->entry = archive_entry_clone(entry); |
| #else |
| l->entry = archive_entry_clone(entry); |
| #endif |
| if (l->entry == NULL) { |
| archive_set_error(&a->archive, ENOMEM, |
| "Can't allocate zip header data"); |
| free(l); |
| return (ARCHIVE_FATAL); |
| } |
| l->flags = zip->flags; |
| if (zip->opt_sconv != NULL) |
| sconv = zip->opt_sconv; |
| else |
| sconv = zip->sconv_default; |
| if (sconv != NULL) { |
| const char *p; |
| size_t len; |
| |
| if (archive_entry_pathname_l(entry, &p, &len, sconv) != 0) { |
| if (errno == ENOMEM) { |
| archive_entry_free(l->entry); |
| free(l); |
| archive_set_error(&a->archive, ENOMEM, |
| "Can't allocate memory for Pathname"); |
| return (ARCHIVE_FATAL); |
| } |
| archive_set_error(&a->archive, |
| ARCHIVE_ERRNO_FILE_FORMAT, |
| "Can't translate Pathname '%s' to %s", |
| archive_entry_pathname(entry), |
| archive_string_conversion_charset_name(sconv)); |
| ret2 = ARCHIVE_WARN; |
| } |
| if (len > 0) |
| archive_entry_set_pathname(l->entry, p); |
| |
| /* |
| * Although there is no character-set regulation for Symlink, |
| * it is suitable to convert a character-set of Symlinke to |
| * what those of the Pathname has been converted to. |
| */ |
| if (type == AE_IFLNK) { |
| if (archive_entry_symlink_l(entry, &p, &len, sconv)) { |
| if (errno == ENOMEM) { |
| archive_entry_free(l->entry); |
| free(l); |
| archive_set_error(&a->archive, ENOMEM, |
| "Can't allocate memory " |
| " for Symlink"); |
| return (ARCHIVE_FATAL); |
| } |
| /* |
| * Even if the strng conversion failed, |
| * we should not report the error since |
| * thre is no regulation for. |
| */ |
| } else if (len > 0) |
| archive_entry_set_symlink(l->entry, p); |
| } |
| } |
| /* If all characters in a filename are ASCII, Reset UTF-8 Name flag. */ |
| if ((l->flags & ZIP_FLAGS_UTF8_NAME) != 0 && |
| is_all_ascii(archive_entry_pathname(l->entry))) |
| l->flags &= ~ZIP_FLAGS_UTF8_NAME; |
| |
| /* Initialize the CRC variable and potentially the local crc32(). */ |
| l->crc32 = crc32(0, NULL, 0); |
| if (type == AE_IFLNK) { |
| const char *p = archive_entry_symlink(l->entry); |
| if (p != NULL) |
| size = strlen(p); |
| else |
| size = 0; |
| zip->remaining_data_bytes = 0; |
| archive_entry_set_size(l->entry, size); |
| l->compression = COMPRESSION_STORE; |
| l->compressed_size = size; |
| } else { |
| l->compression = zip->compression; |
| l->compressed_size = 0; |
| } |
| l->next = NULL; |
| if (zip->central_directory == NULL) { |
| zip->central_directory = l; |
| } else { |
| zip->central_directory_end->next = l; |
| } |
| zip->central_directory_end = l; |
| |
| /* Store the offset of this header for later use in central |
| * directory. */ |
| l->offset = zip->written_bytes; |
| |
| memset(h, 0, sizeof(h)); |
| archive_le32enc(&h[LOCAL_FILE_HEADER_SIGNATURE], |
| ZIP_SIGNATURE_LOCAL_FILE_HEADER); |
| archive_le16enc(&h[LOCAL_FILE_HEADER_VERSION], ZIP_VERSION_EXTRACT); |
| archive_le16enc(&h[LOCAL_FILE_HEADER_FLAGS], l->flags); |
| archive_le16enc(&h[LOCAL_FILE_HEADER_COMPRESSION], l->compression); |
| archive_le32enc(&h[LOCAL_FILE_HEADER_TIMEDATE], |
| dos_time(archive_entry_mtime(entry))); |
| archive_le16enc(&h[LOCAL_FILE_HEADER_FILENAME_LENGTH], |
| (uint16_t)path_length(l->entry)); |
| |
| switch (l->compression) { |
| case COMPRESSION_STORE: |
| /* Setting compressed and uncompressed sizes even when |
| * specification says to set to zero when using data |
| * descriptors. Otherwise the end of the data for an |
| * entry is rather difficult to find. */ |
| archive_le32enc(&h[LOCAL_FILE_HEADER_COMPRESSED_SIZE], |
| (uint32_t)size); |
| archive_le32enc(&h[LOCAL_FILE_HEADER_UNCOMPRESSED_SIZE], |
| (uint32_t)size); |
| break; |
| #ifdef HAVE_ZLIB_H |
| case COMPRESSION_DEFLATE: |
| archive_le32enc(&h[LOCAL_FILE_HEADER_UNCOMPRESSED_SIZE], |
| (uint32_t)size); |
| |
| zip->stream.zalloc = Z_NULL; |
| zip->stream.zfree = Z_NULL; |
| zip->stream.opaque = Z_NULL; |
| zip->stream.next_out = zip->buf; |
| zip->stream.avail_out = zip->len_buf; |
| if (deflateInit2(&zip->stream, Z_DEFAULT_COMPRESSION, |
| Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY) != Z_OK) { |
| archive_set_error(&a->archive, ENOMEM, |
| "Can't init deflate compressor"); |
| return (ARCHIVE_FATAL); |
| } |
| break; |
| #endif |
| } |
| |
| /* Formatting extra data. */ |
| archive_le16enc(&h[LOCAL_FILE_HEADER_EXTRA_LENGTH], sizeof(e)); |
| archive_le16enc(&e[EXTRA_DATA_LOCAL_TIME_ID], |
| ZIP_SIGNATURE_EXTRA_TIMESTAMP); |
| archive_le16enc(&e[EXTRA_DATA_LOCAL_TIME_SIZE], 1 + 4 * 3); |
| e[EXTRA_DATA_LOCAL_TIME_FLAG] = 0x07; |
| archive_le32enc(&e[EXTRA_DATA_LOCAL_MTIME], |
| (uint32_t)archive_entry_mtime(entry)); |
| archive_le32enc(&e[EXTRA_DATA_LOCAL_ATIME], |
| (uint32_t)archive_entry_atime(entry)); |
| archive_le32enc(&e[EXTRA_DATA_LOCAL_CTIME], |
| (uint32_t)archive_entry_ctime(entry)); |
| |
| archive_le16enc(&e[EXTRA_DATA_LOCAL_UNIX_ID], |
| ZIP_SIGNATURE_EXTRA_NEW_UNIX); |
| archive_le16enc(&e[EXTRA_DATA_LOCAL_UNIX_SIZE], 1 + (1 + 4) * 2); |
| e[EXTRA_DATA_LOCAL_UNIX_VERSION] = 1; |
| e[EXTRA_DATA_LOCAL_UNIX_UID_SIZE] = 4; |
| archive_le32enc(&e[EXTRA_DATA_LOCAL_UNIX_UID], |
| (uint32_t)archive_entry_uid(entry)); |
| e[EXTRA_DATA_LOCAL_UNIX_GID_SIZE] = 4; |
| archive_le32enc(&e[EXTRA_DATA_LOCAL_UNIX_GID], |
| (uint32_t)archive_entry_gid(entry)); |
| |
| archive_le32enc(&d[DATA_DESCRIPTOR_UNCOMPRESSED_SIZE], |
| (uint32_t)size); |
| |
| ret = __archive_write_output(a, h, sizeof(h)); |
| if (ret != ARCHIVE_OK) |
| return (ARCHIVE_FATAL); |
| zip->written_bytes += sizeof(h); |
| |
| ret = write_path(l->entry, a); |
| if (ret <= ARCHIVE_OK) |
| return (ARCHIVE_FATAL); |
| zip->written_bytes += ret; |
| |
| ret = __archive_write_output(a, e, sizeof(e)); |
| if (ret != ARCHIVE_OK) |
| return (ARCHIVE_FATAL); |
| zip->written_bytes += sizeof(e); |
| |
| if (type == AE_IFLNK) { |
| const unsigned char *p; |
| |
| p = (const unsigned char *)archive_entry_symlink(l->entry); |
| ret = __archive_write_output(a, p, (size_t)size); |
| if (ret != ARCHIVE_OK) |
| return (ARCHIVE_FATAL); |
| zip->written_bytes += size; |
| l->crc32 = crc32(l->crc32, p, (unsigned)size); |
| } |
| |
| if (ret2 != ARCHIVE_OK) |
| return (ret2); |
| return (ARCHIVE_OK); |
| } |
| |
| static ssize_t |
| archive_write_zip_data(struct archive_write *a, const void *buff, size_t s) |
| { |
| int ret; |
| struct zip *zip = a->format_data; |
| struct zip_file_header_link *l = zip->central_directory_end; |
| |
| if ((int64_t)s > zip->remaining_data_bytes) |
| s = (size_t)zip->remaining_data_bytes; |
| |
| if (s == 0) return 0; |
| |
| switch (l->compression) { |
| case COMPRESSION_STORE: |
| ret = __archive_write_output(a, buff, s); |
| if (ret != ARCHIVE_OK) return (ret); |
| zip->written_bytes += s; |
| zip->remaining_data_bytes -= s; |
| l->compressed_size += s; |
| l->crc32 = crc32(l->crc32, buff, s); |
| return (s); |
| #if HAVE_ZLIB_H |
| case COMPRESSION_DEFLATE: |
| zip->stream.next_in = (unsigned char*)(uintptr_t)buff; |
| zip->stream.avail_in = s; |
| do { |
| ret = deflate(&zip->stream, Z_NO_FLUSH); |
| if (ret == Z_STREAM_ERROR) |
| return (ARCHIVE_FATAL); |
| if (zip->stream.avail_out == 0) { |
| ret = __archive_write_output(a, zip->buf, |
| zip->len_buf); |
| if (ret != ARCHIVE_OK) |
| return (ret); |
| l->compressed_size += zip->len_buf; |
| zip->written_bytes += zip->len_buf; |
| zip->stream.next_out = zip->buf; |
| zip->stream.avail_out = zip->len_buf; |
| } |
| } while (zip->stream.avail_in != 0); |
| zip->remaining_data_bytes -= s; |
| /* If we have it, use zlib's fast crc32() */ |
| l->crc32 = crc32(l->crc32, buff, s); |
| return (s); |
| #endif |
| |
| default: |
| archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, |
| "Invalid ZIP compression type"); |
| return ARCHIVE_FATAL; |
| } |
| } |
| |
| static int |
| archive_write_zip_finish_entry(struct archive_write *a) |
| { |
| /* Write the data descripter after file data has been written. */ |
| int ret; |
| struct zip *zip = a->format_data; |
| uint8_t *d = zip->data_descriptor; |
| struct zip_file_header_link *l = zip->central_directory_end; |
| #if HAVE_ZLIB_H |
| size_t reminder; |
| #endif |
| |
| switch(l->compression) { |
| case COMPRESSION_STORE: |
| break; |
| #if HAVE_ZLIB_H |
| case COMPRESSION_DEFLATE: |
| for (;;) { |
| ret = deflate(&zip->stream, Z_FINISH); |
| if (ret == Z_STREAM_ERROR) |
| return (ARCHIVE_FATAL); |
| reminder = zip->len_buf - zip->stream.avail_out; |
| ret = __archive_write_output(a, zip->buf, reminder); |
| if (ret != ARCHIVE_OK) |
| return (ret); |
| l->compressed_size += reminder; |
| zip->written_bytes += reminder; |
| zip->stream.next_out = zip->buf; |
| if (zip->stream.avail_out != 0) |
| break; |
| zip->stream.avail_out = zip->len_buf; |
| } |
| deflateEnd(&zip->stream); |
| break; |
| #endif |
| } |
| |
| archive_le32enc(&d[DATA_DESCRIPTOR_CRC32], l->crc32); |
| archive_le32enc(&d[DATA_DESCRIPTOR_COMPRESSED_SIZE], |
| (uint32_t)l->compressed_size); |
| ret = __archive_write_output(a, d, SIZE_DATA_DESCRIPTOR); |
| if (ret != ARCHIVE_OK) |
| return (ARCHIVE_FATAL); |
| zip->written_bytes += SIZE_DATA_DESCRIPTOR; |
| return (ARCHIVE_OK); |
| } |
| |
| static int |
| archive_write_zip_close(struct archive_write *a) |
| { |
| struct zip *zip; |
| struct zip_file_header_link *l; |
| uint8_t h[SIZE_FILE_HEADER]; |
| uint8_t end[SIZE_CENTRAL_DIRECTORY_END]; |
| uint8_t e[SIZE_EXTRA_DATA_CENTRAL]; |
| int64_t offset_start, offset_end; |
| int entries; |
| int ret; |
| |
| zip = a->format_data; |
| l = zip->central_directory; |
| |
| /* |
| * Formatting central directory file header fields that are |
| * fixed for all entries. |
| * Fields not used (and therefor 0) are: |
| * |
| * - comment_length |
| * - disk_number |
| * - attributes_internal |
| */ |
| memset(h, 0, sizeof(h)); |
| archive_le32enc(&h[FILE_HEADER_SIGNATURE], ZIP_SIGNATURE_FILE_HEADER); |
| archive_le16enc(&h[FILE_HEADER_VERSION_BY], ZIP_VERSION_BY); |
| archive_le16enc(&h[FILE_HEADER_VERSION_EXTRACT], ZIP_VERSION_EXTRACT); |
| |
| entries = 0; |
| offset_start = zip->written_bytes; |
| |
| /* Formatting individual header fields per entry and |
| * writing each entry. */ |
| while (l != NULL) { |
| archive_le16enc(&h[FILE_HEADER_FLAGS], l->flags); |
| archive_le16enc(&h[FILE_HEADER_COMPRESSION], l->compression); |
| archive_le32enc(&h[FILE_HEADER_TIMEDATE], |
| dos_time(archive_entry_mtime(l->entry))); |
| archive_le32enc(&h[FILE_HEADER_CRC32], l->crc32); |
| archive_le32enc(&h[FILE_HEADER_COMPRESSED_SIZE], |
| (uint32_t)l->compressed_size); |
| archive_le32enc(&h[FILE_HEADER_UNCOMPRESSED_SIZE], |
| (uint32_t)archive_entry_size(l->entry)); |
| archive_le16enc(&h[FILE_HEADER_FILENAME_LENGTH], |
| (uint16_t)path_length(l->entry)); |
| archive_le16enc(&h[FILE_HEADER_EXTRA_LENGTH], sizeof(e)); |
| archive_le16enc(&h[FILE_HEADER_ATTRIBUTES_EXTERNAL+2], |
| archive_entry_mode(l->entry)); |
| archive_le32enc(&h[FILE_HEADER_OFFSET], (uint32_t)l->offset); |
| |
| /* Formatting extra data. */ |
| archive_le16enc(&e[EXTRA_DATA_CENTRAL_TIME_ID], |
| ZIP_SIGNATURE_EXTRA_TIMESTAMP); |
| archive_le16enc(&e[EXTRA_DATA_CENTRAL_TIME_SIZE], 1 + 4); |
| e[EXTRA_DATA_CENTRAL_TIME_FLAG] = 0x07; |
| archive_le32enc(&e[EXTRA_DATA_CENTRAL_MTIME], |
| (uint32_t)archive_entry_mtime(l->entry)); |
| archive_le16enc(&e[EXTRA_DATA_CENTRAL_UNIX_ID], |
| ZIP_SIGNATURE_EXTRA_NEW_UNIX); |
| archive_le16enc(&e[EXTRA_DATA_CENTRAL_UNIX_SIZE], 0x0000); |
| |
| ret = __archive_write_output(a, h, sizeof(h)); |
| if (ret != ARCHIVE_OK) |
| return (ARCHIVE_FATAL); |
| zip->written_bytes += sizeof(h); |
| |
| ret = write_path(l->entry, a); |
| if (ret <= ARCHIVE_OK) |
| return (ARCHIVE_FATAL); |
| zip->written_bytes += ret; |
| |
| ret = __archive_write_output(a, e, sizeof(e)); |
| if (ret != ARCHIVE_OK) |
| return (ARCHIVE_FATAL); |
| zip->written_bytes += sizeof(e); |
| |
| l = l->next; |
| entries++; |
| } |
| offset_end = zip->written_bytes; |
| |
| /* Formatting end of central directory. */ |
| memset(end, 0, sizeof(end)); |
| archive_le32enc(&end[CENTRAL_DIRECTORY_END_SIGNATURE], |
| ZIP_SIGNATURE_CENTRAL_DIRECTORY_END); |
| archive_le16enc(&end[CENTRAL_DIRECTORY_END_ENTRIES_DISK], entries); |
| archive_le16enc(&end[CENTRAL_DIRECTORY_END_ENTRIES], entries); |
| archive_le32enc(&end[CENTRAL_DIRECTORY_END_SIZE], |
| (uint32_t)(offset_end - offset_start)); |
| archive_le32enc(&end[CENTRAL_DIRECTORY_END_OFFSET], |
| (uint32_t)offset_start); |
| |
| /* Writing end of central directory. */ |
| ret = __archive_write_output(a, end, sizeof(end)); |
| if (ret != ARCHIVE_OK) |
| return (ARCHIVE_FATAL); |
| zip->written_bytes += sizeof(end); |
| return (ARCHIVE_OK); |
| } |
| |
| static int |
| archive_write_zip_free(struct archive_write *a) |
| { |
| struct zip *zip; |
| struct zip_file_header_link *l; |
| |
| zip = a->format_data; |
| while (zip->central_directory != NULL) { |
| l = zip->central_directory; |
| zip->central_directory = l->next; |
| archive_entry_free(l->entry); |
| free(l); |
| } |
| #ifdef HAVE_ZLIB_H |
| free(zip->buf); |
| #endif |
| free(zip); |
| a->format_data = NULL; |
| return (ARCHIVE_OK); |
| } |
| |
| /* Convert into MSDOS-style date/time. */ |
| static unsigned int |
| dos_time(const time_t unix_time) |
| { |
| struct tm *t; |
| unsigned int dt; |
| |
| /* This will not preserve time when creating/extracting the archive |
| * on two systems with different time zones. */ |
| t = localtime(&unix_time); |
| |
| /* MSDOS-style date/time is only between 1980-01-01 and 2107-12-31 */ |
| if (t->tm_year < 1980 - 1900) |
| /* Set minimum date/time '1980-01-01 00:00:00'. */ |
| dt = 0x00210000U; |
| else if (t->tm_year > 2107 - 1900) |
| /* Set maximum date/time '2107-12-31 23:59:58'. */ |
| dt = 0xff9fbf7dU; |
| else { |
| dt = 0; |
| dt += ((t->tm_year - 80) & 0x7f) << 9; |
| dt += ((t->tm_mon + 1) & 0x0f) << 5; |
| dt += (t->tm_mday & 0x1f); |
| dt <<= 16; |
| dt += (t->tm_hour & 0x1f) << 11; |
| dt += (t->tm_min & 0x3f) << 5; |
| dt += (t->tm_sec & 0x3e) >> 1; /* Only counting every 2 seconds. */ |
| } |
| return dt; |
| } |
| |
| static size_t |
| path_length(struct archive_entry *entry) |
| { |
| mode_t type; |
| const char *path; |
| |
| type = archive_entry_filetype(entry); |
| path = archive_entry_pathname(entry); |
| |
| if ((type == AE_IFDIR) & (path[strlen(path) - 1] != '/')) { |
| return strlen(path) + 1; |
| } else { |
| return strlen(path); |
| } |
| } |
| |
| static int |
| write_path(struct archive_entry *entry, struct archive_write *archive) |
| { |
| int ret; |
| const char *path; |
| mode_t type; |
| size_t written_bytes; |
| |
| path = archive_entry_pathname(entry); |
| type = archive_entry_filetype(entry); |
| written_bytes = 0; |
| |
| ret = __archive_write_output(archive, path, strlen(path)); |
| if (ret != ARCHIVE_OK) |
| return (ARCHIVE_FATAL); |
| written_bytes += strlen(path); |
| |
| /* Folders are recognized by a traling slash. */ |
| if ((type == AE_IFDIR) & (path[strlen(path) - 1] != '/')) { |
| ret = __archive_write_output(archive, "/", 1); |
| if (ret != ARCHIVE_OK) |
| return (ARCHIVE_FATAL); |
| written_bytes += 1; |
| } |
| |
| return ((int)written_bytes); |
| } |