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);
}
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;
if ((int64_t)s > zip->entry_uncompressed_limit)
s = (size_t)zip->entry_uncompressed_limit;
zip->entry_uncompressed_written += s;
if (s == 0) return 0;
switch (zip->entry_compression) {
case COMPRESSION_STORE:
ret = __archive_write_output(a, buff, s);
if (ret != ARCHIVE_OK)
return (ret);
zip->written_bytes += s;
zip->entry_compressed_written += s;
break;
#if HAVE_ZLIB_H
case COMPRESSION_DEFLATE:
zip->stream.next_in = (unsigned char*)(uintptr_t)buff;
zip->stream.avail_in = (uInt)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);
zip->entry_compressed_written += zip->len_buf;
zip->written_bytes += zip->len_buf;
zip->stream.next_out = zip->buf;
zip->stream.avail_out = (uInt)zip->len_buf;
}
} while (zip->stream.avail_in != 0);
break;
#endif
default:
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Invalid ZIP compression type");
return ARCHIVE_FATAL;
}
zip->entry_uncompressed_limit -= s;
zip->entry_crc32 = zip->crc32func(zip->entry_crc32, buff, (unsigned)s);
return (s);
}
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, (unsigned)s);
return (s);
#if HAVE_ZLIB_H
case COMPRESSION_DEFLATE:
zip->stream.next_in = (unsigned char*)(uintptr_t)buff;
zip->stream.avail_in = (uInt)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 = (uInt)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, (uInt)s);
return (s);
#endif
default:
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Invalid ZIP compression type");
return ARCHIVE_FATAL;
}
}
static ssize_t
archive_write_ar_data(struct archive_write *a, const void *buff, size_t s)
{
struct ar_w *ar;
int ret;
ar = (struct ar_w *)a->format_data;
if (s > ar->entry_bytes_remaining)
s = (size_t)ar->entry_bytes_remaining;
if (ar->is_strtab > 0) {
if (ar->has_strtab > 0) {
archive_set_error(&a->archive, EINVAL,
"More than one string tables exist");
return (ARCHIVE_WARN);
}
ar->strtab = (char *)malloc(s);
if (ar->strtab == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate strtab buffer");
return (ARCHIVE_FATAL);
}
strncpy(ar->strtab, buff, s);
ar->has_strtab = 1;
}
ret = __archive_write_output(a, buff, s);
if (ret != ARCHIVE_OK)
return (ret);
ar->entry_bytes_remaining -= s;
return (s);
}
static int
archive_write_ar_finish_entry(struct archive_write *a)
{
struct ar_w *ar;
int ret;
ar = (struct ar_w *)a->format_data;
if (ar->entry_bytes_remaining != 0) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Entry remaining bytes larger than 0");
return (ARCHIVE_WARN);
}
if (ar->entry_padding == 0) {
return (ARCHIVE_OK);
}
if (ar->entry_padding != 1) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Padding wrong size: %ju should be 1 or 0",
(uintmax_t)ar->entry_padding);
return (ARCHIVE_WARN);
}
ret = __archive_write_output(a, "\n", 1);
return (ret);
}
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 = (uInt)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 ssize_t
archive_write_shar_data_uuencode(struct archive_write *a, const void *buff,
size_t length)
{
struct shar *shar;
const char *src;
size_t n;
int ret;
shar = (struct shar *)a->format_data;
if (!shar->has_data)
return (ARCHIVE_OK);
src = (const char *)buff;
if (shar->outpos != 0) {
n = 45 - shar->outpos;
if (n > length)
n = length;
memcpy(shar->outbuff + shar->outpos, src, n);
if (shar->outpos + n < 45) {
shar->outpos += n;
return length;
}
uuencode_line(a, shar, shar->outbuff, 45);
src += n;
n = length - n;
} else {
n = length;
}
while (n >= 45) {
uuencode_line(a, shar, src, 45);
src += 45;
n -= 45;
if (shar->work.length < 65536)
continue;
ret = __archive_write_output(a, shar->work.s,
shar->work.length);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
archive_string_empty(&shar->work);
}
if (n != 0) {
memcpy(shar->outbuff, src, n);
shar->outpos = n;
}
return (length);
}
int
__archive_write_nulls(struct archive_write *a, size_t length)
{
if (length == 0)
return (ARCHIVE_OK);
while (length > 0) {
size_t to_write = length < a->null_length ? length : a->null_length;
int r = __archive_write_output(a, a->nulls, to_write);
if (r < ARCHIVE_OK)
return (r);
length -= to_write;
}
return (ARCHIVE_OK);
}
static ssize_t
archive_write_gnutar_data(struct archive_write *a, const void *buff, size_t s)
{
struct gnutar *gnutar;
int ret;
gnutar = (struct gnutar *)a->format_data;
if (s > gnutar->entry_bytes_remaining)
s = (size_t)gnutar->entry_bytes_remaining;
ret = __archive_write_output(a, buff, s);
gnutar->entry_bytes_remaining -= s;
if (ret != ARCHIVE_OK)
return (ret);
return (s);
}
static int
_warc_finish_entry(struct archive_write *a)
{
static const char _eor[] = "\r\n\r\n";
struct warc_s *w = a->format_data;
if (w->typ == AE_IFREG) {
int rc = __archive_write_output(a, _eor, sizeof(_eor) - 1U);
if (rc != ARCHIVE_OK) {
return rc;
}
}
/* reset type info */
w->typ = 0;
return (ARCHIVE_OK);
}
static ssize_t
archive_write_newc_data(struct archive_write *a, const void *buff, size_t s)
{
struct cpio *cpio;
int ret;
cpio = (struct cpio *)a->format_data;
if (s > cpio->entry_bytes_remaining)
s = (size_t)cpio->entry_bytes_remaining;
ret = __archive_write_output(a, buff, s);
cpio->entry_bytes_remaining -= s;
if (ret >= 0)
return (s);
else
return (ret);
}
static int
archive_write_ar_close(struct archive_write *a)
{
struct ar_w *ar;
int ret;
/*
* If we haven't written anything yet, we need to write
* the ar global header now to make it a valid ar archive.
*/
ar = (struct ar_w *)a->format_data;
if (!ar->wrote_global_header) {
ar->wrote_global_header = 1;
ret = __archive_write_output(a, "!<arch>\n", 8);
return (ret);
}
return (ARCHIVE_OK);
}
static ssize_t
_warc_data(struct archive_write *a, const void *buf, size_t len)
{
struct warc_s *w = a->format_data;
if (w->typ == AE_IFREG) {
int rc;
/* never write more bytes than announced */
if (len > w->populz) {
len = (size_t)w->populz;
}
/* now then, out we put the whole shebang */
rc = __archive_write_output(a, buf, len);
if (rc != ARCHIVE_OK) {
return rc;
}
}
return len;
}
static int
archive_write_shar_close(struct archive_write *a)
{
struct shar *shar;
int ret;
/*
* TODO: Accumulate list of directory names/modes and
* fix them all up at end-of-archive.
*/
shar = (struct shar *)a->format_data;
/*
* Only write the end-of-archive markers if the archive was
* actually started. This avoids problems if someone sets
* shar format, then sets another format (which would invoke
* shar_finish to free the format-specific data).
*/
if (shar->wrote_header == 0)
return (ARCHIVE_OK);
archive_strcat(&shar->work, "exit\n");
ret = __archive_write_output(a, shar->work.s, shar->work.length);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
/* Shar output is never padded. */
archive_write_set_bytes_in_last_block(&a->archive, 1);
/*
* TODO: shar should also suppress padding of
* uncompressed data within gzip/bzip2 streams.
*/
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_header(struct archive_write *a, struct archive_entry *entry)
{
unsigned char local_header[32];
unsigned char local_extra[128];
struct zip *zip = a->format_data;
unsigned char *e;
unsigned char *cd_extra;
size_t filename_length;
const char *slink = NULL;
size_t slink_size = 0;
struct archive_string_conv *sconv = get_sconv(a, zip);
int ret, ret2 = ARCHIVE_OK;
int64_t size;
mode_t type;
int version_needed = 10;
/* Ignore types of entries that we don't support. */
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;
};
/* If we're not using Zip64, reject large files. */
if (zip->flags & ZIP_FLAG_AVOID_ZIP64) {
/* Reject entries over 4GB. */
if (archive_entry_size_is_set(entry)
&& (archive_entry_size(entry) > 0xffffffff)) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Files > 4GB require Zip64 extensions");
return ARCHIVE_FAILED;
}
/* Reject entries if archive is > 4GB. */
if (zip->written_bytes > 0xffffffff) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Archives > 4GB require Zip64 extensions");
return ARCHIVE_FAILED;
}
}
/* Only regular files can have size > 0. */
if (type != AE_IFREG)
archive_entry_set_size(entry, 0);
/* Reset information from last entry. */
zip->entry_offset = zip->written_bytes;
zip->entry_uncompressed_limit = INT64_MAX;
zip->entry_compressed_size = 0;
zip->entry_uncompressed_size = 0;
zip->entry_compressed_written = 0;
zip->entry_uncompressed_written = 0;
zip->entry_flags = 0;
zip->entry_uses_zip64 = 0;
zip->entry_crc32 = zip->crc32func(0, NULL, 0);
if (zip->entry != NULL) {
archive_entry_free(zip->entry);
zip->entry = NULL;
}
#if defined(_WIN32) && !defined(__CYGWIN__)
/* Make sure the path separators in pahtname, hardlink and symlink
* are all slash '/', not the Windows path separator '\'. */
zip->entry = __la_win_entry_in_posix_pathseparator(entry);
if (zip->entry == entry)
zip->entry = archive_entry_clone(entry);
#else
zip->entry = archive_entry_clone(entry);
#endif
if (zip->entry == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate zip header data");
return (ARCHIVE_FATAL);
}
if (sconv != NULL) {
const char *p;
size_t len;
if (archive_entry_pathname_l(entry, &p, &len, sconv) != 0) {
if (errno == ENOMEM) {
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(zip->entry, p);
/*
* There is no standard for symlink handling; we convert
* it using the same character-set translation that we use
* for filename.
*/
if (type == AE_IFLNK) {
if (archive_entry_symlink_l(entry, &p, &len, sconv)) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory "
" for Symlink");
return (ARCHIVE_FATAL);
}
/* No error if we can't convert. */
} else if (len > 0)
archive_entry_set_symlink(zip->entry, p);
}
}
/* If filename isn't ASCII and we can use UTF-8, set the UTF-8 flag. */
if (!is_all_ascii(archive_entry_pathname(zip->entry))) {
if (zip->opt_sconv != NULL) {
if (strcmp(archive_string_conversion_charset_name(
zip->opt_sconv), "UTF-8") == 0)
zip->entry_flags |= ZIP_ENTRY_FLAG_UTF8_NAME;
#if HAVE_NL_LANGINFO
} else if (strcmp(nl_langinfo(CODESET), "UTF-8") == 0) {
zip->entry_flags |= ZIP_ENTRY_FLAG_UTF8_NAME;
#endif
}
}
filename_length = path_length(zip->entry);
/* Determine appropriate compression and size for this entry. */
if (type == AE_IFLNK) {
slink = archive_entry_symlink(zip->entry);
if (slink != NULL)
slink_size = strlen(slink);
else
slink_size = 0;
zip->entry_uncompressed_limit = slink_size;
zip->entry_compressed_size = slink_size;
zip->entry_uncompressed_size = slink_size;
zip->entry_crc32 = zip->crc32func(zip->entry_crc32,
(const unsigned char *)slink, slink_size);
zip->entry_compression = COMPRESSION_STORE;
version_needed = 20;
} else if (type != AE_IFREG) {
zip->entry_compression = COMPRESSION_STORE;
zip->entry_uncompressed_limit = 0;
size = 0;
version_needed = 20;
} else if (archive_entry_size_is_set(zip->entry)) {
size = archive_entry_size(zip->entry);
zip->entry_uncompressed_limit = size;
zip->entry_compression = zip->requested_compression;
if (zip->entry_compression == COMPRESSION_UNSPECIFIED) {
zip->entry_compression = COMPRESSION_DEFAULT;
}
if (zip->entry_compression == COMPRESSION_STORE) {
zip->entry_compressed_size = size;
zip->entry_uncompressed_size = size;
version_needed = 10;
} else {
zip->entry_uncompressed_size = size;
version_needed = 20;
}
if ((zip->flags & ZIP_FLAG_FORCE_ZIP64) /* User asked. */
|| (zip->entry_uncompressed_size > ARCHIVE_LITERAL_LL(0xffffffff))) { /* Large entry. */
zip->entry_uses_zip64 = 1;
version_needed = 45;
}
/* We may know the size, but never the CRC. */
zip->entry_flags |= ZIP_ENTRY_FLAG_LENGTH_AT_END;
} else {
/* Prefer deflate if it's available, because deflate
* has a clear end-of-data marker that makes
* length-at-end more reliable. */
zip->entry_compression = COMPRESSION_DEFAULT;
zip->entry_flags |= ZIP_ENTRY_FLAG_LENGTH_AT_END;
if ((zip->flags & ZIP_FLAG_AVOID_ZIP64) == 0) {
zip->entry_uses_zip64 = 1;
version_needed = 45;
} else if (zip->entry_compression == COMPRESSION_STORE) {
version_needed = 10;
} else {
version_needed = 20;
}
}
/* Format the local header. */
memset(local_header, 0, sizeof(local_header));
memcpy(local_header, "PK\003\004", 4);
archive_le16enc(local_header + 4, version_needed);
archive_le16enc(local_header + 6, zip->entry_flags);
archive_le16enc(local_header + 8, zip->entry_compression);
archive_le32enc(local_header + 10, dos_time(archive_entry_mtime(zip->entry)));
archive_le32enc(local_header + 14, zip->entry_crc32);
if (zip->entry_uses_zip64) {
/* Zip64 data in the local header "must" include both
* compressed and uncompressed sizes AND those fields
* are included only if these are 0xffffffff;
* THEREFORE these must be set this way, even if we
* know one of them is smaller. */
archive_le32enc(local_header + 18, ARCHIVE_LITERAL_LL(0xffffffff));
archive_le32enc(local_header + 22, ARCHIVE_LITERAL_LL(0xffffffff));
} else {
archive_le32enc(local_header + 18, zip->entry_compressed_size);
archive_le32enc(local_header + 22, zip->entry_uncompressed_size);
}
archive_le16enc(local_header + 26, filename_length);
/* Format as much of central directory file header as we can: */
zip->file_header = cd_alloc(zip, 46);
/* If (zip->file_header == NULL) XXXX */
++zip->central_directory_entries;
memset(zip->file_header, 0, 46);
memcpy(zip->file_header, "PK\001\002", 4);
/* "Made by PKZip 2.0 on Unix." */
archive_le16enc(zip->file_header + 4, 3 * 256 + version_needed);
archive_le16enc(zip->file_header + 6, version_needed);
archive_le16enc(zip->file_header + 8, zip->entry_flags);
archive_le16enc(zip->file_header + 10, zip->entry_compression);
archive_le32enc(zip->file_header + 12, dos_time(archive_entry_mtime(zip->entry)));
archive_le16enc(zip->file_header + 28, filename_length);
/* Following Info-Zip, store mode in the "external attributes" field. */
archive_le32enc(zip->file_header + 38,
((uint32_t)archive_entry_mode(zip->entry)) << 16);
e = cd_alloc(zip, filename_length);
/* If (e == NULL) XXXX */
copy_path(zip->entry, e);
/* Format extra data. */
memset(local_extra, 0, sizeof(local_extra));
e = local_extra;
/* First, extra blocks that are the same between
* the local file header and the central directory.
* We format them once and then duplicate them. */
/* UT timestamp, length depends on what timestamps are set. */
memcpy(e, "UT", 2);
archive_le16enc(e + 2,
1
+ (archive_entry_mtime_is_set(entry) ? 4 : 0)
+ (archive_entry_atime_is_set(entry) ? 4 : 0)
+ (archive_entry_ctime_is_set(entry) ? 4 : 0));
e += 4;
*e++ =
(archive_entry_mtime_is_set(entry) ? 1 : 0)
| (archive_entry_atime_is_set(entry) ? 2 : 0)
| (archive_entry_ctime_is_set(entry) ? 4 : 0);
if (archive_entry_mtime_is_set(entry)) {
archive_le32enc(e, (uint32_t)archive_entry_mtime(entry));
e += 4;
}
if (archive_entry_atime_is_set(entry)) {
archive_le32enc(e, (uint32_t)archive_entry_atime(entry));
e += 4;
}
if (archive_entry_ctime_is_set(entry)) {
archive_le32enc(e, (uint32_t)archive_entry_ctime(entry));
e += 4;
}
/* ux Unix extra data, length 11, version 1 */
/* TODO: If uid < 64k, use 2 bytes, ditto for gid. */
memcpy(e, "ux\013\000\001", 5);
e += 5;
*e++ = 4; /* Length of following UID */
archive_le32enc(e, (uint32_t)archive_entry_uid(entry));
e += 4;
*e++ = 4; /* Length of following GID */
archive_le32enc(e, (uint32_t)archive_entry_gid(entry));
e += 4;
/* Copy UT and ux into central directory as well. */
zip->file_header_extra_offset = zip->central_directory_bytes;
cd_extra = cd_alloc(zip, e - local_extra);
memcpy(cd_extra, local_extra, e - local_extra);
/*
* Following extra blocks vary between local header and
* central directory. These are the local header versions.
* Central directory versions get formatted in
* archive_write_zip_finish_entry() below.
*/
/* "[Zip64 entry] in the local header MUST include BOTH
* original [uncompressed] and compressed size fields." */
if (zip->entry_uses_zip64) {
unsigned char *zip64_start = e;
memcpy(e, "\001\000\020\000", 4);
e += 4;
archive_le64enc(e, zip->entry_uncompressed_size);
e += 8;
archive_le64enc(e, zip->entry_compressed_size);
e += 8;
archive_le16enc(zip64_start + 2, e - (zip64_start + 4));
}
if (zip->flags & ZIP_FLAG_EXPERIMENT_EL) {
/* Experimental 'el' extension to improve streaming. */
unsigned char *external_info = e;
int included = 7;
memcpy(e, "el\000\000", 4); // 0x6c65 + 2-byte length
e += 4;
e[0] = included; /* bitmap of included fields */
e += 1;
if (included & 1) {
archive_le16enc(e, /* "Version created by" */
3 * 256 + version_needed);
e += 2;
}
if (included & 2) {
archive_le16enc(e, 0); /* internal file attributes */
e += 2;
}
if (included & 4) {
archive_le32enc(e, /* external file attributes */
((uint32_t)archive_entry_mode(zip->entry)) << 16);
e += 4;
}
if (included & 8) {
// Libarchive does not currently support file comments.
}
archive_le16enc(external_info + 2, e - (external_info + 4));
}
/* Update local header with size of extra data and write it all out: */
archive_le16enc(local_header + 28, e - local_extra);
ret = __archive_write_output(a, local_header, 30);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += 30;
ret = write_path(zip->entry, a);
if (ret <= ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += ret;
ret = __archive_write_output(a, local_extra, e - local_extra);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += e - local_extra;
/* For symlinks, write the body now. */
if (slink != NULL) {
ret = __archive_write_output(a, slink, slink_size);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->entry_compressed_written += slink_size;
zip->entry_uncompressed_written += slink_size;
zip->written_bytes += slink_size;
}
#ifdef HAVE_ZLIB_H
if (zip->entry_compression == COMPRESSION_DEFLATE) {
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 = (uInt)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);
}
}
#endif
return (ret2);
}
static int
archive_write_zip_close(struct archive_write *a)
{
uint8_t buff[64];
int64_t offset_start, offset_end;
struct zip *zip = a->format_data;
struct cd_segment *segment;
int ret;
offset_start = zip->written_bytes;
segment = zip->central_directory;
while (segment != NULL) {
ret = __archive_write_output(a,
segment->buff, segment->p - segment->buff);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += segment->p - segment->buff;
segment = segment->next;
}
offset_end = zip->written_bytes;
/* If central dir info is too large, write Zip64 end-of-cd */
if (offset_end - offset_start > ARCHIVE_LITERAL_LL(0xffffffff)
|| offset_start > ARCHIVE_LITERAL_LL(0xffffffff)
|| zip->central_directory_entries > 0xffffUL
|| (zip->flags & ZIP_FLAG_FORCE_ZIP64)) {
/* Zip64 end-of-cd record */
memset(buff, 0, 56);
memcpy(buff, "PK\006\006", 4);
archive_le64enc(buff + 4, 44);
archive_le16enc(buff + 12, 45);
archive_le16enc(buff + 14, 45);
/* This is disk 0 of 0. */
archive_le64enc(buff + 24, zip->central_directory_entries);
archive_le64enc(buff + 32, zip->central_directory_entries);
archive_le64enc(buff + 40, offset_end - offset_start);
archive_le64enc(buff + 48, offset_start);
ret = __archive_write_output(a, buff, 56);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += 56;
/* Zip64 end-of-cd locator record. */
memset(buff, 0, 20);
memcpy(buff, "PK\006\007", 4);
archive_le32enc(buff + 4, 0);
archive_le64enc(buff + 8, offset_end);
archive_le32enc(buff + 16, 1);
ret = __archive_write_output(a, buff, 20);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += 20;
}
/* Format and write end of central directory. */
memset(buff, 0, sizeof(buff));
memcpy(buff, "PK\005\006", 4);
archive_le16enc(buff + 8, zipmin(0xffffU, zip->central_directory_entries));
archive_le16enc(buff + 10, zipmin(0xffffU, zip->central_directory_entries));
archive_le32enc(buff + 12, (uint32_t)zipmin(ARCHIVE_LITERAL_LL(0xffffffff), (offset_end - offset_start)));
archive_le32enc(buff + 16, (uint32_t)zipmin(ARCHIVE_LITERAL_LL(0xffffffff), offset_start));
ret = __archive_write_output(a, buff, 22);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += 22;
return (ARCHIVE_OK);
}
static int
archive_write_zip_finish_entry(struct archive_write *a)
{
struct zip *zip = a->format_data;
int ret;
#if HAVE_ZLIB_H
if (zip->entry_compression == COMPRESSION_DEFLATE) {
for (;;) {
size_t remainder;
ret = deflate(&zip->stream, Z_FINISH);
if (ret == Z_STREAM_ERROR)
return (ARCHIVE_FATAL);
remainder = zip->len_buf - zip->stream.avail_out;
ret = __archive_write_output(a, zip->buf, remainder);
if (ret != ARCHIVE_OK)
return (ret);
zip->entry_compressed_written += remainder;
zip->written_bytes += remainder;
zip->stream.next_out = zip->buf;
if (zip->stream.avail_out != 0)
break;
zip->stream.avail_out = (uInt)zip->len_buf;
}
deflateEnd(&zip->stream);
}
#endif
/* Write trailing data descriptor. */
if ((zip->entry_flags & ZIP_ENTRY_FLAG_LENGTH_AT_END) != 0) {
char d[24];
memcpy(d, "PK\007\010", 4);
archive_le32enc(d + 4, zip->entry_crc32);
if (zip->entry_uses_zip64) {
archive_le64enc(d + 8, (uint64_t)zip->entry_compressed_written);
archive_le64enc(d + 16, (uint64_t)zip->entry_uncompressed_written);
ret = __archive_write_output(a, d, 24);
zip->written_bytes += 24;
} else {
archive_le32enc(d + 8, (uint32_t)zip->entry_compressed_written);
archive_le32enc(d + 12, (uint32_t)zip->entry_uncompressed_written);
ret = __archive_write_output(a, d, 16);
zip->written_bytes += 16;
}
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
}
/* Append Zip64 extra data to central directory information. */
if (zip->entry_compressed_written > ARCHIVE_LITERAL_LL(0xffffffff)
|| zip->entry_uncompressed_written > ARCHIVE_LITERAL_LL(0xffffffff)
|| zip->entry_offset > ARCHIVE_LITERAL_LL(0xffffffff)) {
unsigned char zip64[32];
unsigned char *z = zip64, *zd;
memcpy(z, "\001\000\000\000", 4);
z += 4;
if (zip->entry_uncompressed_written >= ARCHIVE_LITERAL_LL(0xffffffff)) {
archive_le64enc(z, zip->entry_uncompressed_written);
z += 8;
}
if (zip->entry_compressed_written >= ARCHIVE_LITERAL_LL(0xffffffff)) {
archive_le64enc(z, zip->entry_compressed_written);
z += 8;
}
if (zip->entry_offset >= ARCHIVE_LITERAL_LL(0xffffffff)) {
archive_le64enc(z, zip->entry_offset);
z += 8;
}
archive_le16enc(zip64 + 2, z - (zip64 + 4));
zd = cd_alloc(zip, z - zip64);
if (zd == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate zip data");
return (ARCHIVE_FATAL);
}
memcpy(zd, zip64, z - zip64);
/* Zip64 means version needs to be set to at least 4.5 */
if (archive_le16dec(zip->file_header + 6) < 45)
archive_le16enc(zip->file_header + 6, 45);
}
/* Fix up central directory file header. */
archive_le32enc(zip->file_header + 16, zip->entry_crc32);
archive_le32enc(zip->file_header + 20,
zipmin(zip->entry_compressed_written, ARCHIVE_LITERAL_LL(0xffffffff)));
archive_le32enc(zip->file_header + 24,
zipmin(zip->entry_uncompressed_written, ARCHIVE_LITERAL_LL(0xffffffff)));
archive_le16enc(zip->file_header + 30,
zip->central_directory_bytes - zip->file_header_extra_offset);
archive_le32enc(zip->file_header + 42,
zipmin(zip->entry_offset, ARCHIVE_LITERAL_LL(0xffffffff)));
return (ARCHIVE_OK);
}
static int
archive_write_v7tar_header(struct archive_write *a, struct archive_entry *entry)
{
char buff[512];
int ret, ret2;
struct v7tar *v7tar;
struct archive_entry *entry_main;
struct archive_string_conv *sconv;
v7tar = (struct v7tar *)a->format_data;
/* Setup default string conversion. */
if (v7tar->opt_sconv == NULL) {
if (!v7tar->init_default_conversion) {
v7tar->sconv_default =
archive_string_default_conversion_for_write(
&(a->archive));
v7tar->init_default_conversion = 1;
}
sconv = v7tar->sconv_default;
} else
sconv = v7tar->opt_sconv;
/* Sanity check. */
if (archive_entry_pathname(entry) == NULL) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Can't record entry in tar file without pathname");
return (ARCHIVE_FAILED);
}
/* Only regular files (not hardlinks) have data. */
if (archive_entry_hardlink(entry) != NULL ||
archive_entry_symlink(entry) != NULL ||
!(archive_entry_filetype(entry) == AE_IFREG))
archive_entry_set_size(entry, 0);
if (AE_IFDIR == archive_entry_filetype(entry)) {
const char *p;
size_t path_length;
/*
* Ensure a trailing '/'. Modify the entry so
* the client sees the change.
*/
#if defined(_WIN32) && !defined(__CYGWIN__)
const wchar_t *wp;
wp = archive_entry_pathname_w(entry);
if (wp != NULL && wp[wcslen(wp) -1] != L'/') {
struct archive_wstring ws;
archive_string_init(&ws);
path_length = wcslen(wp);
if (archive_wstring_ensure(&ws,
path_length + 2) == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate v7tar data");
archive_wstring_free(&ws);
return(ARCHIVE_FATAL);
}
/* Should we keep '\' ? */
if (wp[path_length -1] == L'\\')
path_length--;
archive_wstrncpy(&ws, wp, path_length);
archive_wstrappend_wchar(&ws, L'/');
archive_entry_copy_pathname_w(entry, ws.s);
archive_wstring_free(&ws);
p = NULL;
} else
#endif
p = archive_entry_pathname(entry);
/*
* On Windows, this is a backup operation just in
* case getting WCS failed. On POSIX, this is a
* normal operation.
*/
if (p != NULL && p[strlen(p) - 1] != '/') {
struct archive_string as;
archive_string_init(&as);
path_length = strlen(p);
if (archive_string_ensure(&as,
path_length + 2) == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate v7tar data");
archive_string_free(&as);
return(ARCHIVE_FATAL);
}
#if defined(_WIN32) && !defined(__CYGWIN__)
/* NOTE: This might break the pathname
* if the current code page is CP932 and
* the pathname includes a character '\'
* as a part of its multibyte pathname. */
if (p[strlen(p) -1] == '\\')
path_length--;
else
#endif
archive_strncpy(&as, p, path_length);
archive_strappend_char(&as, '/');
archive_entry_copy_pathname(entry, as.s);
archive_string_free(&as);
}
}
#if defined(_WIN32) && !defined(__CYGWIN__)
/* Make sure the path separators in pahtname, hardlink and symlink
* are all slash '/', not the Windows path separator '\'. */
entry_main = __la_win_entry_in_posix_pathseparator(entry);
if (entry_main == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate v7tar data");
return(ARCHIVE_FATAL);
}
if (entry != entry_main)
entry = entry_main;
else
entry_main = NULL;
#else
entry_main = NULL;
#endif
ret = format_header_v7tar(a, buff, entry, 1, sconv);
if (ret < ARCHIVE_WARN) {
if (entry_main)
archive_entry_free(entry_main);
return (ret);
}
ret2 = __archive_write_output(a, buff, 512);
if (ret2 < ARCHIVE_WARN) {
if (entry_main)
archive_entry_free(entry_main);
return (ret2);
}
if (ret2 < ret)
ret = ret2;
v7tar->entry_bytes_remaining = archive_entry_size(entry);
v7tar->entry_padding = 0x1ff & (-(int64_t)v7tar->entry_bytes_remaining);
if (entry_main)
archive_entry_free(entry_main);
return (ret);
}
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 = (uInt)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 int
archive_write_zip_close(struct archive_write *a)
{
struct zip *zip;
struct zip_file_header_link *l;
struct zip_file_header h;
struct zip_central_directory_end end;
struct zip_extra_data_central e;
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.signature, ZIP_SIGNATURE_FILE_HEADER);
archive_le16enc(&h.version_by, ZIP_VERSION_BY);
archive_le16enc(&h.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.flags, l->flags);
archive_le16enc(&h.compression, l->compression);
archive_le32enc(&h.timedate, dos_time(archive_entry_mtime(l->entry)));
archive_le32enc(&h.crc32, l->crc32);
archive_le32enc(&h.compressed_size, l->compressed_size);
archive_le32enc(&h.uncompressed_size, archive_entry_size(l->entry));
archive_le16enc(&h.filename_length, (uint16_t)path_length(l->entry));
archive_le16enc(&h.extra_length, sizeof(e));
archive_le16enc(&h.attributes_external[2], archive_entry_mode(l->entry));
archive_le32enc(&h.offset, l->offset);
/* Formatting extra data. */
archive_le16enc(&e.time_id, ZIP_SIGNATURE_EXTRA_TIMESTAMP);
archive_le16enc(&e.time_size, sizeof(e.mtime) + sizeof(e.time_flag));
e.time_flag[0] = 0x07;
archive_le32enc(&e.mtime, archive_entry_mtime(l->entry));
archive_le16enc(&e.unix_id, ZIP_SIGNATURE_EXTRA_NEW_UNIX);
archive_le16enc(&e.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.signature, ZIP_SIGNATURE_CENTRAL_DIRECTORY_END);
archive_le16enc(&end.entries_disk, entries);
archive_le16enc(&end.entries, entries);
archive_le32enc(&end.size, offset_end - offset_start);
archive_le32enc(&end.offset, 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_header(struct archive_write *a, struct archive_entry *entry)
{
struct zip *zip;
struct zip_local_file_header h;
struct zip_extra_data_local e;
struct zip_data_descriptor *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)) {
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);
}
l->entry = archive_entry_clone(entry);
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_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);
}
/* If all character of a filename is 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);
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.signature, ZIP_SIGNATURE_LOCAL_FILE_HEADER);
archive_le16enc(&h.version, ZIP_VERSION_EXTRACT);
archive_le16enc(&h.flags, l->flags);
archive_le16enc(&h.compression, zip->compression);
archive_le32enc(&h.timedate, dos_time(archive_entry_mtime(entry)));
archive_le16enc(&h.filename_length, (uint16_t)path_length(l->entry));
switch (zip->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.compressed_size, size);
archive_le32enc(&h.uncompressed_size, size);
break;
#ifdef HAVE_ZLIB_H
case COMPRESSION_DEFLATE:
archive_le32enc(&h.uncompressed_size, 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.extra_length, sizeof(e));
archive_le16enc(&e.time_id, ZIP_SIGNATURE_EXTRA_TIMESTAMP);
archive_le16enc(&e.time_size, sizeof(e.time_flag) +
sizeof(e.mtime) + sizeof(e.atime) + sizeof(e.ctime));
e.time_flag[0] = 0x07;
archive_le32enc(&e.mtime, archive_entry_mtime(entry));
archive_le32enc(&e.atime, archive_entry_atime(entry));
archive_le32enc(&e.ctime, archive_entry_ctime(entry));
archive_le16enc(&e.unix_id, ZIP_SIGNATURE_EXTRA_NEW_UNIX);
archive_le16enc(&e.unix_size, sizeof(e.unix_version) +
sizeof(e.unix_uid_size) + sizeof(e.unix_uid) +
sizeof(e.unix_gid_size) + sizeof(e.unix_gid));
e.unix_version = 1;
e.unix_uid_size = 4;
archive_le32enc(&e.unix_uid, archive_entry_uid(entry));
e.unix_gid_size = 4;
archive_le32enc(&e.unix_gid, archive_entry_gid(entry));
archive_le32enc(&d->uncompressed_size, 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 (ret2 != ARCHIVE_OK)
return (ret2);
return (ARCHIVE_OK);
}
static int
archive_write_gnutar_header(struct archive_write *a,
struct archive_entry *entry)
{
char buff[512];
int r, ret, ret2 = ARCHIVE_OK;
int tartype;
struct gnutar *gnutar;
struct archive_string_conv *sconv;
gnutar = (struct gnutar *)a->format_data;
/* Setup default string conversion. */
if (gnutar->opt_sconv == NULL) {
if (!gnutar->init_default_conversion) {
gnutar->sconv_default =
archive_string_default_conversion_for_write(
&(a->archive));
gnutar->init_default_conversion = 1;
}
sconv = gnutar->sconv_default;
} else
sconv = gnutar->opt_sconv;
/* Only regular files (not hardlinks) have data. */
if (archive_entry_hardlink(entry) != NULL ||
archive_entry_symlink(entry) != NULL ||
!(archive_entry_filetype(entry) == AE_IFREG))
archive_entry_set_size(entry, 0);
if (AE_IFDIR == archive_entry_filetype(entry)) {
const char *p;
char *t;
/*
* Ensure a trailing '/'. Modify the entry so
* the client sees the change.
*/
p = archive_entry_pathname(entry);
if (p[strlen(p) - 1] != '/') {
t = (char *)malloc(strlen(p) + 2);
if (t == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate gnutar data");
return(ARCHIVE_FATAL);
}
strcpy(t, p);
strcat(t, "/");
archive_entry_copy_pathname(entry, t);
free(t);
}
}
r = archive_entry_pathname_l(entry, &(gnutar->pathname),
&(gnutar->pathname_length), sconv);
if (r != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Pathame");
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;
}
r = archive_entry_uname_l(entry, &(gnutar->uname),
&(gnutar->uname_length), sconv);
if (r != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Uname");
return (ARCHIVE_FATAL);
}
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Can't translate uname '%s' to %s",
archive_entry_uname(entry),
archive_string_conversion_charset_name(sconv));
ret2 = ARCHIVE_WARN;
}
r = archive_entry_gname_l(entry, &(gnutar->gname),
&(gnutar->gname_length), sconv);
if (r != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Gname");
return (ARCHIVE_FATAL);
}
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Can't translate gname '%s' to %s",
archive_entry_gname(entry),
archive_string_conversion_charset_name(sconv));
ret2 = ARCHIVE_WARN;
}
/* If linkname is longer than 100 chars we need to add a 'K' header. */
r = archive_entry_hardlink_l(entry, &(gnutar->linkname),
&(gnutar->linkname_length), sconv);
if (r != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Linkname");
return (ARCHIVE_FATAL);
}
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Can't translate linkname '%s' to %s",
archive_entry_hardlink(entry),
archive_string_conversion_charset_name(sconv));
ret2 = ARCHIVE_WARN;
}
if (gnutar->linkname_length == 0) {
r = archive_entry_symlink_l(entry, &(gnutar->linkname),
&(gnutar->linkname_length), sconv);
if (r != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Linkname");
return (ARCHIVE_FATAL);
}
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Can't translate linkname '%s' to %s",
archive_entry_hardlink(entry),
archive_string_conversion_charset_name(sconv));
ret2 = ARCHIVE_WARN;
}
}
if (gnutar->linkname_length > GNUTAR_linkname_size) {
size_t todo = gnutar->linkname_length;
struct archive_entry *temp = archive_entry_new2(&a->archive);
/* Uname/gname here don't really matter since no one reads them;
* these are the values that GNU tar happens to use on FreeBSD. */
archive_entry_set_uname(temp, "root");
archive_entry_set_gname(temp, "wheel");
archive_entry_set_pathname(temp, "././@LongLink");
archive_entry_set_size(temp, gnutar->linkname_length + 1);
ret = archive_format_gnutar_header(a, buff, temp, 'K');
if (ret < ARCHIVE_WARN)
return (ret);
ret = __archive_write_output(a, buff, 512);
if(ret < ARCHIVE_WARN)
return (ret);
archive_entry_free(temp);
/* Write as many 512 bytes blocks as needed to write full name. */
ret = __archive_write_output(a, gnutar->linkname, todo);
if(ret < ARCHIVE_WARN)
return (ret);
ret = __archive_write_nulls(a, 0x1ff & (-(ssize_t)todo));
if (ret < ARCHIVE_WARN)
return (ret);
}
/* If pathname is longer than 100 chars we need to add an 'L' header. */
if (gnutar->pathname_length > GNUTAR_name_size) {
const char *pathname = gnutar->pathname;
size_t todo = gnutar->pathname_length;
struct archive_entry *temp = archive_entry_new2(&a->archive);
/* Uname/gname here don't really matter since no one reads them;
* these are the values that GNU tar happens to use on FreeBSD. */
archive_entry_set_uname(temp, "root");
archive_entry_set_gname(temp, "wheel");
archive_entry_set_pathname(temp, "././@LongLink");
archive_entry_set_size(temp, gnutar->pathname_length + 1);
ret = archive_format_gnutar_header(a, buff, temp, 'L');
if (ret < ARCHIVE_WARN)
return (ret);
ret = __archive_write_output(a, buff, 512);
if(ret < ARCHIVE_WARN)
return (ret);
archive_entry_free(temp);
/* Write as many 512 bytes blocks as needed to write full name. */
ret = __archive_write_output(a, pathname, todo);
if(ret < ARCHIVE_WARN)
return (ret);
ret = __archive_write_nulls(a, 0x1ff & (-(ssize_t)todo));
if (ret < ARCHIVE_WARN)
return (ret);
}
if (archive_entry_hardlink(entry) != NULL) {
tartype = '1';
} else
switch (archive_entry_filetype(entry)) {
case AE_IFREG: tartype = '0' ; break;
case AE_IFLNK: tartype = '2' ; break;
case AE_IFCHR: tartype = '3' ; break;
case AE_IFBLK: tartype = '4' ; break;
case AE_IFDIR: tartype = '5' ; break;
case AE_IFIFO: tartype = '6' ; break;
case AE_IFSOCK:
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"tar format cannot archive socket");
return (ARCHIVE_FAILED);
default:
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"tar format cannot archive this (mode=0%lo)",
(unsigned long)archive_entry_mode(entry));
return (ARCHIVE_FAILED);
}
ret = archive_format_gnutar_header(a, buff, entry, tartype);
if (ret < ARCHIVE_WARN)
return (ret);
if (ret2 < ret)
ret = ret2;
ret2 = __archive_write_output(a, buff, 512);
if (ret2 < ARCHIVE_WARN)
return (ret2);
if (ret2 < ret)
ret = ret2;
gnutar->entry_bytes_remaining = archive_entry_size(entry);
gnutar->entry_padding = 0x1ff & (-(int64_t)gnutar->entry_bytes_remaining);
return (ret);
}
static int
archive_write_ar_header(struct archive_write *a, struct archive_entry *entry)
{
int ret, append_fn;
char buff[60];
char *ss, *se;
struct ar_w *ar;
const char *pathname;
const char *filename;
int64_t size;
append_fn = 0;
ar = (struct ar_w *)a->format_data;
ar->is_strtab = 0;
filename = NULL;
size = archive_entry_size(entry);
/*
* Reject files with empty name.
*/
pathname = archive_entry_pathname(entry);
if (pathname == NULL || *pathname == '\0') {
archive_set_error(&a->archive, EINVAL,
"Invalid filename");
return (ARCHIVE_WARN);
}
/*
* If we are now at the beginning of the archive,
* we need first write the ar global header.
*/
if (!ar->wrote_global_header) {
__archive_write_output(a, "!<arch>\n", 8);
ar->wrote_global_header = 1;
}
memset(buff, ' ', 60);
strncpy(&buff[AR_fmag_offset], "`\n", 2);
if (strcmp(pathname, "/") == 0 ) {
/* Entry is archive symbol table in GNU format */
buff[AR_name_offset] = '/';
goto stat;
}
if (strcmp(pathname, "__.SYMDEF") == 0) {
/* Entry is archive symbol table in BSD format */
strncpy(buff + AR_name_offset, "__.SYMDEF", 9);
goto stat;
}
if (strcmp(pathname, "//") == 0) {
/*
* Entry is archive filename table, inform that we should
* collect strtab in next _data call.
*/
ar->is_strtab = 1;
buff[AR_name_offset] = buff[AR_name_offset + 1] = '/';
/*
* For archive string table, only ar_size field should
* be set.
*/
goto size;
}
/*
* Otherwise, entry is a normal archive member.
* Strip leading paths from filenames, if any.
*/
if ((filename = ar_basename(pathname)) == NULL) {
/* Reject filenames with trailing "/" */
archive_set_error(&a->archive, EINVAL,
"Invalid filename");
return (ARCHIVE_WARN);
}
if (a->archive.archive_format == ARCHIVE_FORMAT_AR_GNU) {
/*
* SVR4/GNU variant use a "/" to mark then end of the filename,
* make it possible to have embedded spaces in the filename.
* So, the longest filename here (without extension) is
* actually 15 bytes.
*/
if (strlen(filename) <= 15) {
strncpy(&buff[AR_name_offset],
filename, strlen(filename));
buff[AR_name_offset + strlen(filename)] = '/';
} else {
/*
* For filename longer than 15 bytes, GNU variant
* makes use of a string table and instead stores the
* offset of the real filename to in the ar_name field.
* The string table should have been written before.
*/
if (ar->has_strtab <= 0) {
archive_set_error(&a->archive, EINVAL,
"Can't find string table");
return (ARCHIVE_WARN);
}
se = (char *)malloc(strlen(filename) + 3);
if (se == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate filename buffer");
return (ARCHIVE_FATAL);
}
strncpy(se, filename, strlen(filename));
strcpy(se + strlen(filename), "/\n");
ss = strstr(ar->strtab, se);
free(se);
if (ss == NULL) {
archive_set_error(&a->archive, EINVAL,
"Invalid string table");
return (ARCHIVE_WARN);
}
/*
* GNU variant puts "/" followed by digits into
* ar_name field. These digits indicates the real
* filename string's offset to the string table.
*/
buff[AR_name_offset] = '/';
if (format_decimal(ss - ar->strtab,
buff + AR_name_offset + 1,
AR_name_size - 1)) {
archive_set_error(&a->archive, ERANGE,
"string table offset too large");
return (ARCHIVE_WARN);
}
}
} else if (a->archive.archive_format == ARCHIVE_FORMAT_AR_BSD) {
/*
* BSD variant: for any file name which is more than
* 16 chars or contains one or more embedded space(s), the
* string "#1/" followed by the ASCII length of the name is
* put into the ar_name field. The file size (stored in the
* ar_size field) is incremented by the length of the name.
* The name is then written immediately following the
* archive header.
*/
if (strlen(filename) <= 16 && strchr(filename, ' ') == NULL) {
strncpy(&buff[AR_name_offset], filename, strlen(filename));
buff[AR_name_offset + strlen(filename)] = ' ';
}
else {
strncpy(buff + AR_name_offset, "#1/", 3);
if (format_decimal(strlen(filename),
buff + AR_name_offset + 3,
AR_name_size - 3)) {
archive_set_error(&a->archive, ERANGE,
"File name too long");
return (ARCHIVE_WARN);
}
append_fn = 1;
size += strlen(filename);
}
}
stat:
if (format_decimal(archive_entry_mtime(entry), buff + AR_date_offset, AR_date_size)) {
archive_set_error(&a->archive, ERANGE,
"File modification time too large");
return (ARCHIVE_WARN);
}
if (format_decimal(archive_entry_uid(entry), buff + AR_uid_offset, AR_uid_size)) {
archive_set_error(&a->archive, ERANGE,
"Numeric user ID too large");
return (ARCHIVE_WARN);
}
if (format_decimal(archive_entry_gid(entry), buff + AR_gid_offset, AR_gid_size)) {
archive_set_error(&a->archive, ERANGE,
"Numeric group ID too large");
return (ARCHIVE_WARN);
}
if (format_octal(archive_entry_mode(entry), buff + AR_mode_offset, AR_mode_size)) {
archive_set_error(&a->archive, ERANGE,
"Numeric mode too large");
return (ARCHIVE_WARN);
}
/*
* Sanity Check: A non-pseudo archive member should always be
* a regular file.
*/
if (filename != NULL && archive_entry_filetype(entry) != AE_IFREG) {
archive_set_error(&a->archive, EINVAL,
"Regular file required for non-pseudo member");
return (ARCHIVE_WARN);
}
size:
if (format_decimal(size, buff + AR_size_offset, AR_size_size)) {
archive_set_error(&a->archive, ERANGE,
"File size out of range");
return (ARCHIVE_WARN);
}
ret = __archive_write_output(a, buff, 60);
if (ret != ARCHIVE_OK)
return (ret);
ar->entry_bytes_remaining = size;
ar->entry_padding = ar->entry_bytes_remaining % 2;
if (append_fn > 0) {
ret = __archive_write_output(a, filename, strlen(filename));
if (ret != ARCHIVE_OK)
return (ret);
ar->entry_bytes_remaining -= strlen(filename);
}
return (ARCHIVE_OK);
}
static int
write_header(struct archive_write *a, struct archive_entry *entry)
{
int64_t ino;
struct cpio *cpio;
const char *p, *path;
int pathlength, ret, ret_final;
char h[c_header_size];
struct archive_string_conv *sconv;
struct archive_entry *entry_main;
size_t len;
int pad;
cpio = (struct cpio *)a->format_data;
ret_final = ARCHIVE_OK;
sconv = get_sconv(a);
#if defined(_WIN32) && !defined(__CYGWIN__)
/* Make sure the path separators in pahtname, hardlink and symlink
* are all slash '/', not the Windows path separator '\'. */
entry_main = __la_win_entry_in_posix_pathseparator(entry);
if (entry_main == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate ustar data");
return(ARCHIVE_FATAL);
}
if (entry != entry_main)
entry = entry_main;
else
entry_main = NULL;
#else
entry_main = NULL;
#endif
ret = archive_entry_pathname_l(entry, &path, &len, sconv);
if (ret != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Pathname");
ret_final = ARCHIVE_FATAL;
goto exit_write_header;
}
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));
ret_final = ARCHIVE_WARN;
}
pathlength = (int)len + 1; /* Include trailing null. */
memset(h, 0, c_header_size);
format_hex(0x070701, h + c_magic_offset, c_magic_size);
format_hex(archive_entry_devmajor(entry), h + c_devmajor_offset,
c_devmajor_size);
format_hex(archive_entry_devminor(entry), h + c_devminor_offset,
c_devminor_size);
ino = archive_entry_ino64(entry);
if (ino > 0xffffffff) {
archive_set_error(&a->archive, ERANGE,
"large inode number truncated");
ret_final = ARCHIVE_WARN;
}
/* TODO: Set ret_final to ARCHIVE_WARN if any of these overflow. */
format_hex(ino & 0xffffffff, h + c_ino_offset, c_ino_size);
format_hex(archive_entry_mode(entry), h + c_mode_offset, c_mode_size);
format_hex(archive_entry_uid(entry), h + c_uid_offset, c_uid_size);
format_hex(archive_entry_gid(entry), h + c_gid_offset, c_gid_size);
format_hex(archive_entry_nlink(entry), h + c_nlink_offset, c_nlink_size);
if (archive_entry_filetype(entry) == AE_IFBLK
|| archive_entry_filetype(entry) == AE_IFCHR) {
format_hex(archive_entry_rdevmajor(entry), h + c_rdevmajor_offset, c_rdevmajor_size);
format_hex(archive_entry_rdevminor(entry), h + c_rdevminor_offset, c_rdevminor_size);
} else {
format_hex(0, h + c_rdevmajor_offset, c_rdevmajor_size);
format_hex(0, h + c_rdevminor_offset, c_rdevminor_size);
}
format_hex(archive_entry_mtime(entry), h + c_mtime_offset, c_mtime_size);
format_hex(pathlength, h + c_namesize_offset, c_namesize_size);
format_hex(0, h + c_checksum_offset, c_checksum_size);
/* Non-regular files don't store bodies. */
if (archive_entry_filetype(entry) != AE_IFREG)
archive_entry_set_size(entry, 0);
/* Symlinks get the link written as the body of the entry. */
ret = archive_entry_symlink_l(entry, &p, &len, sconv);
if (ret != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Likname");
ret_final = ARCHIVE_FATAL;
goto exit_write_header;
}
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Can't translate linkname '%s' to %s",
archive_entry_symlink(entry),
archive_string_conversion_charset_name(sconv));
ret_final = ARCHIVE_WARN;
}
if (len > 0 && p != NULL && *p != '\0')
ret = format_hex(strlen(p), h + c_filesize_offset,
c_filesize_size);
else
ret = format_hex(archive_entry_size(entry),
h + c_filesize_offset, c_filesize_size);
if (ret) {
archive_set_error(&a->archive, ERANGE,
"File is too large for this format.");
ret_final = ARCHIVE_FAILED;
goto exit_write_header;
}
ret = __archive_write_output(a, h, c_header_size);
if (ret != ARCHIVE_OK) {
ret_final = ARCHIVE_FATAL;
goto exit_write_header;
}
/* Pad pathname to even length. */
ret = __archive_write_output(a, path, pathlength);
if (ret != ARCHIVE_OK) {
ret_final = ARCHIVE_FATAL;
goto exit_write_header;
}
pad = PAD4(pathlength + c_header_size);
if (pad) {
ret = __archive_write_output(a, "\0\0\0", pad);
if (ret != ARCHIVE_OK) {
ret_final = ARCHIVE_FATAL;
goto exit_write_header;
}
}
cpio->entry_bytes_remaining = archive_entry_size(entry);
cpio->padding = (int)PAD4(cpio->entry_bytes_remaining);
/* Write the symlink now. */
if (p != NULL && *p != '\0') {
ret = __archive_write_output(a, p, strlen(p));
if (ret != ARCHIVE_OK) {
ret_final = ARCHIVE_FATAL;
goto exit_write_header;
}
pad = PAD4(strlen(p));
ret = __archive_write_output(a, "\0\0\0", pad);
if (ret != ARCHIVE_OK) {
ret_final = ARCHIVE_FATAL;
goto exit_write_header;
}
}
exit_write_header:
if (entry_main)
archive_entry_free(entry_main);
return (ret_final);
}
static int
archive_write_gnutar_header(struct archive_write *a,
struct archive_entry *entry)
{
char buff[512];
int r, ret, ret2 = ARCHIVE_OK;
int tartype;
struct gnutar *gnutar;
struct archive_string_conv *sconv;
struct archive_entry *entry_main;
gnutar = (struct gnutar *)a->format_data;
/* Setup default string conversion. */
if (gnutar->opt_sconv == NULL) {
if (!gnutar->init_default_conversion) {
gnutar->sconv_default =
archive_string_default_conversion_for_write(
&(a->archive));
gnutar->init_default_conversion = 1;
}
sconv = gnutar->sconv_default;
} else
sconv = gnutar->opt_sconv;
/* Only regular files (not hardlinks) have data. */
if (archive_entry_hardlink(entry) != NULL ||
archive_entry_symlink(entry) != NULL ||
!(archive_entry_filetype(entry) == AE_IFREG))
archive_entry_set_size(entry, 0);
if (AE_IFDIR == archive_entry_filetype(entry)) {
const char *p;
size_t path_length;
/*
* Ensure a trailing '/'. Modify the entry so
* the client sees the change.
*/
#if defined(_WIN32) && !defined(__CYGWIN__)
const wchar_t *wp;
wp = archive_entry_pathname_w(entry);
if (wp != NULL && wp[wcslen(wp) -1] != L'/') {
struct archive_wstring ws;
archive_string_init(&ws);
path_length = wcslen(wp);
if (archive_wstring_ensure(&ws,
path_length + 2) == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate ustar data");
archive_wstring_free(&ws);
return(ARCHIVE_FATAL);
}
/* Should we keep '\' ? */
if (wp[path_length -1] == L'\\')
path_length--;
archive_wstrncpy(&ws, wp, path_length);
archive_wstrappend_wchar(&ws, L'/');
archive_entry_copy_pathname_w(entry, ws.s);
archive_wstring_free(&ws);
p = NULL;
} else
#endif
p = archive_entry_pathname(entry);
/*
* On Windows, this is a backup operation just in
* case getting WCS failed. On POSIX, this is a
* normal operation.
*/
if (p != NULL && p[0] != '\0' && p[strlen(p) - 1] != '/') {
struct archive_string as;
archive_string_init(&as);
path_length = strlen(p);
if (archive_string_ensure(&as,
path_length + 2) == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate ustar data");
archive_string_free(&as);
return(ARCHIVE_FATAL);
}
#if defined(_WIN32) && !defined(__CYGWIN__)
/* NOTE: This might break the pathname
* if the current code page is CP932 and
* the pathname includes a character '\'
* as a part of its multibyte pathname. */
if (p[strlen(p) -1] == '\\')
path_length--;
else
#endif
archive_strncpy(&as, p, path_length);
archive_strappend_char(&as, '/');
archive_entry_copy_pathname(entry, as.s);
archive_string_free(&as);
}
}
#if defined(_WIN32) && !defined(__CYGWIN__)
/* Make sure the path separators in pathname, hardlink and symlink
* are all slash '/', not the Windows path separator '\'. */
entry_main = __la_win_entry_in_posix_pathseparator(entry);
if (entry_main == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate ustar data");
return(ARCHIVE_FATAL);
}
if (entry != entry_main)
entry = entry_main;
else
entry_main = NULL;
#else
entry_main = NULL;
#endif
r = archive_entry_pathname_l(entry, &(gnutar->pathname),
&(gnutar->pathname_length), sconv);
if (r != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Pathame");
ret = ARCHIVE_FATAL;
goto exit_write_header;
}
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;
}
r = archive_entry_uname_l(entry, &(gnutar->uname),
&(gnutar->uname_length), sconv);
if (r != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Uname");
ret = ARCHIVE_FATAL;
goto exit_write_header;
}
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Can't translate uname '%s' to %s",
archive_entry_uname(entry),
archive_string_conversion_charset_name(sconv));
ret2 = ARCHIVE_WARN;
}
r = archive_entry_gname_l(entry, &(gnutar->gname),
&(gnutar->gname_length), sconv);
if (r != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Gname");
ret = ARCHIVE_FATAL;
goto exit_write_header;
}
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Can't translate gname '%s' to %s",
archive_entry_gname(entry),
archive_string_conversion_charset_name(sconv));
ret2 = ARCHIVE_WARN;
}
/* If linkname is longer than 100 chars we need to add a 'K' header. */
r = archive_entry_hardlink_l(entry, &(gnutar->linkname),
&(gnutar->linkname_length), sconv);
if (r != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Linkname");
ret = ARCHIVE_FATAL;
goto exit_write_header;
}
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Can't translate linkname '%s' to %s",
archive_entry_hardlink(entry),
archive_string_conversion_charset_name(sconv));
ret2 = ARCHIVE_WARN;
}
if (gnutar->linkname_length == 0) {
r = archive_entry_symlink_l(entry, &(gnutar->linkname),
&(gnutar->linkname_length), sconv);
if (r != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Linkname");
ret = ARCHIVE_FATAL;
goto exit_write_header;
}
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Can't translate linkname '%s' to %s",
archive_entry_hardlink(entry),
archive_string_conversion_charset_name(sconv));
ret2 = ARCHIVE_WARN;
}
}
if (gnutar->linkname_length > GNUTAR_linkname_size) {
size_t length = gnutar->linkname_length + 1;
struct archive_entry *temp = archive_entry_new2(&a->archive);
/* Uname/gname here don't really matter since no one reads them;
* these are the values that GNU tar happens to use on FreeBSD. */
archive_entry_set_uname(temp, "root");
archive_entry_set_gname(temp, "wheel");
archive_entry_set_pathname(temp, "././@LongLink");
archive_entry_set_size(temp, length);
ret = archive_format_gnutar_header(a, buff, temp, 'K');
archive_entry_free(temp);
if (ret < ARCHIVE_WARN)
goto exit_write_header;
ret = __archive_write_output(a, buff, 512);
if (ret < ARCHIVE_WARN)
goto exit_write_header;
/* Write name and trailing null byte. */
ret = __archive_write_output(a, gnutar->linkname, length);
if (ret < ARCHIVE_WARN)
goto exit_write_header;
/* Pad to 512 bytes */
ret = __archive_write_nulls(a, 0x1ff & (-(ssize_t)length));
if (ret < ARCHIVE_WARN)
goto exit_write_header;
}
/* If pathname is longer than 100 chars we need to add an 'L' header. */
if (gnutar->pathname_length > GNUTAR_name_size) {
const char *pathname = gnutar->pathname;
size_t length = gnutar->pathname_length + 1;
struct archive_entry *temp = archive_entry_new2(&a->archive);
/* Uname/gname here don't really matter since no one reads them;
* these are the values that GNU tar happens to use on FreeBSD. */
archive_entry_set_uname(temp, "root");
archive_entry_set_gname(temp, "wheel");
archive_entry_set_pathname(temp, "././@LongLink");
archive_entry_set_size(temp, length);
ret = archive_format_gnutar_header(a, buff, temp, 'L');
archive_entry_free(temp);
if (ret < ARCHIVE_WARN)
goto exit_write_header;
ret = __archive_write_output(a, buff, 512);
if(ret < ARCHIVE_WARN)
goto exit_write_header;
/* Write pathname + trailing null byte. */
ret = __archive_write_output(a, pathname, length);
if(ret < ARCHIVE_WARN)
goto exit_write_header;
/* Pad to multiple of 512 bytes. */
ret = __archive_write_nulls(a, 0x1ff & (-(ssize_t)length));
if (ret < ARCHIVE_WARN)
goto exit_write_header;
}
if (archive_entry_hardlink(entry) != NULL) {
tartype = '1';
} else
switch (archive_entry_filetype(entry)) {
case AE_IFREG: tartype = '0' ; break;
case AE_IFLNK: tartype = '2' ; break;
case AE_IFCHR: tartype = '3' ; break;
case AE_IFBLK: tartype = '4' ; break;
case AE_IFDIR: tartype = '5' ; break;
case AE_IFIFO: tartype = '6' ; break;
case AE_IFSOCK:
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"tar format cannot archive socket");
ret = ARCHIVE_FAILED;
goto exit_write_header;
default:
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"tar format cannot archive this (mode=0%lo)",
(unsigned long)archive_entry_mode(entry));
ret = ARCHIVE_FAILED;
goto exit_write_header;
}
ret = archive_format_gnutar_header(a, buff, entry, tartype);
if (ret < ARCHIVE_WARN)
goto exit_write_header;
if (ret2 < ret)
ret = ret2;
ret2 = __archive_write_output(a, buff, 512);
if (ret2 < ARCHIVE_WARN) {
ret = ret2;
goto exit_write_header;
}
if (ret2 < ret)
ret = ret2;
gnutar->entry_bytes_remaining = archive_entry_size(entry);
gnutar->entry_padding = 0x1ff & (-(int64_t)gnutar->entry_bytes_remaining);
exit_write_header:
archive_entry_free(entry_main);
return (ret);
}
static ssize_t
archive_write_shar_data_sed(struct archive_write *a, const void *buff, size_t n)
{
static const size_t ensured = 65533;
struct shar *shar;
const char *src;
char *buf, *buf_end;
int ret;
size_t written = n;
shar = (struct shar *)a->format_data;
if (!shar->has_data || n == 0)
return (0);
src = (const char *)buff;
/*
* ensure is the number of bytes in buffer before expanding the
* current character. Each operation writes the current character
* and optionally the start-of-new-line marker. This can happen
* twice before entering the loop, so make sure three additional
* bytes can be written.
*/
if (archive_string_ensure(&shar->work, ensured + 3) == NULL) {
archive_set_error(&a->archive, ENOMEM, "Out of memory");
return (ARCHIVE_FATAL);
}
if (shar->work.length > ensured) {
ret = __archive_write_output(a, shar->work.s,
shar->work.length);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
archive_string_empty(&shar->work);
}
buf = shar->work.s + shar->work.length;
buf_end = shar->work.s + ensured;
if (shar->end_of_line) {
*buf++ = 'X';
shar->end_of_line = 0;
}
while (n-- != 0) {
if ((*buf++ = *src++) == '\n') {
if (n == 0)
shar->end_of_line = 1;
else
*buf++ = 'X';
}
if (buf >= buf_end) {
shar->work.length = buf - shar->work.s;
ret = __archive_write_output(a, shar->work.s,
shar->work.length);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
archive_string_empty(&shar->work);
buf = shar->work.s;
}
}
shar->work.length = buf - shar->work.s;
return (written);
}
static int
_warc_header(struct archive_write *a, struct archive_entry *entry)
{
struct warc_s *w = a->format_data;
struct archive_string hdr;
#define MAX_HDR_SIZE 512
/* check whether warcinfo record needs outputting */
if (!w->omit_warcinfo) {
ssize_t r;
warc_essential_hdr_t wi = {
WT_INFO,
/*uri*/NULL,
/*urn*/NULL,
/*rtm*/0,
/*mtm*/0,
/*cty*/"application/warc-fields",
/*len*/sizeof(warcinfo) - 1U,
};
wi.rtime = w->now;
wi.mtime = w->now;
archive_string_init(&hdr);
r = _popul_ehdr(&hdr, MAX_HDR_SIZE, wi);
if (r >= 0) {
/* jackpot! */
/* now also use HDR buffer for the actual warcinfo */
archive_strncat(&hdr, warcinfo, sizeof(warcinfo) -1);
/* append end-of-record indicator */
archive_strncat(&hdr, "\r\n\r\n", 4);
/* write to output stream */
__archive_write_output(a, hdr.s, archive_strlen(&hdr));
}
/* indicate we're done with file header writing */
w->omit_warcinfo = 1U;
archive_string_free(&hdr);
}
if (archive_entry_pathname(entry) == NULL) {
archive_set_error(&a->archive, EINVAL,
"Invalid filename");
return (ARCHIVE_WARN);
}
w->typ = archive_entry_filetype(entry);
w->populz = 0U;
if (w->typ == AE_IFREG) {
warc_essential_hdr_t rh = {
WT_RSRC,
/*uri*/NULL,
/*urn*/NULL,
/*rtm*/0,
/*mtm*/0,
/*cty*/NULL,
/*len*/0,
};
ssize_t r;
rh.tgturi = archive_entry_pathname(entry);
rh.rtime = w->now;
rh.mtime = archive_entry_mtime(entry);
rh.cntlen = (size_t)archive_entry_size(entry);
archive_string_init(&hdr);
r = _popul_ehdr(&hdr, MAX_HDR_SIZE, rh);
if (r < 0) {
/* don't bother */
archive_set_error(
&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"cannot archive file");
return (ARCHIVE_WARN);
}
/* otherwise append to output stream */
__archive_write_output(a, hdr.s, r);
/* and let subsequent calls to _data() know about the size */
w->populz = rh.cntlen;
archive_string_free(&hdr);
return (ARCHIVE_OK);
}
/* just resort to erroring as per Tim's advice */
archive_set_error(
&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"WARC can only process regular files");
return (ARCHIVE_FAILED);
}
static int
archive_write_shar_finish_entry(struct archive_write *a)
{
const char *g, *p, *u;
struct shar *shar;
int ret;
shar = (struct shar *)a->format_data;
if (shar->entry == NULL)
return (0);
if (shar->dump) {
/* Finish uuencoded data. */
if (shar->has_data) {
if (shar->outpos > 0)
uuencode_line(a, shar, shar->outbuff,
shar->outpos);
archive_strcat(&shar->work, "`\nend\n");
archive_strcat(&shar->work, "SHAR_END\n");
}
/* Restore file mode, owner, flags. */
/*
* TODO: Don't immediately restore mode for
* directories; defer that to end of script.
*/
archive_string_sprintf(&shar->work, "chmod %o ",
(unsigned int)(archive_entry_mode(shar->entry) & 07777));
shar_quote(&shar->work, archive_entry_pathname(shar->entry), 1);
archive_strcat(&shar->work, "\n");
u = archive_entry_uname(shar->entry);
g = archive_entry_gname(shar->entry);
if (u != NULL || g != NULL) {
archive_strcat(&shar->work, "chown ");
if (u != NULL)
shar_quote(&shar->work, u, 1);
if (g != NULL) {
archive_strcat(&shar->work, ":");
shar_quote(&shar->work, g, 1);
}
archive_strcat(&shar->work, " ");
shar_quote(&shar->work,
archive_entry_pathname(shar->entry), 1);
archive_strcat(&shar->work, "\n");
}
if ((p = archive_entry_fflags_text(shar->entry)) != NULL) {
archive_string_sprintf(&shar->work, "chflags %s ", p);
shar_quote(&shar->work,
archive_entry_pathname(shar->entry), 1);
archive_strcat(&shar->work, "\n");
}
/* TODO: restore ACLs */
} else {
if (shar->has_data) {
/* Finish sed-encoded data: ensure last line ends. */
if (!shar->end_of_line)
archive_strappend_char(&shar->work, '\n');
archive_strcat(&shar->work, "SHAR_END\n");
}
}
archive_entry_free(shar->entry);
shar->entry = NULL;
if (shar->work.length < 65536)
return (ARCHIVE_OK);
ret = __archive_write_output(a, shar->work.s, shar->work.length);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
archive_string_empty(&shar->work);
return (ARCHIVE_OK);
}