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_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_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 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);
}
/*
* Format a basic 512-byte "v7tar" header.
*
* Returns -1 if format failed (due to field overflow).
* Note that this always formats as much of the header as possible.
* If "strict" is set to zero, it will extend numeric fields as
* necessary (overwriting terminators or using base-256 extensions).
*
*/
static int
format_header_v7tar(struct archive_write *a, char h[512],
struct archive_entry *entry, int strict,
struct archive_string_conv *sconv)
{
unsigned int checksum;
int i, r, ret;
size_t copy_length;
const char *p, *pp;
int mytartype;
ret = 0;
mytartype = -1;
/*
* The "template header" already includes the "v7tar"
* signature, various end-of-field markers and other required
* elements.
*/
memcpy(h, &template_header, 512);
/*
* Because the block is already null-filled, and strings
* are allowed to exactly fill their destination (without null),
* I use memcpy(dest, src, strlen()) here a lot to copy strings.
*/
r = archive_entry_pathname_l(entry, &pp, ©_length, sconv);
if (r != 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",
pp, archive_string_conversion_charset_name(sconv));
ret = ARCHIVE_WARN;
}
if (strict && copy_length < V7TAR_name_size)
memcpy(h + V7TAR_name_offset, pp, copy_length);
else if (!strict && copy_length <= V7TAR_name_size)
memcpy(h + V7TAR_name_offset, pp, copy_length);
else {
/* Prefix is too long. */
archive_set_error(&a->archive, ENAMETOOLONG,
"Pathname too long");
ret = ARCHIVE_FAILED;
}
r = archive_entry_hardlink_l(entry, &p, ©_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",
p, archive_string_conversion_charset_name(sconv));
ret = ARCHIVE_WARN;
}
if (copy_length > 0)
mytartype = '1';
else {
r = archive_entry_symlink_l(entry, &p, ©_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",
p, archive_string_conversion_charset_name(sconv));
ret = ARCHIVE_WARN;
}
}
if (copy_length > 0) {
if (copy_length >= V7TAR_linkname_size) {
archive_set_error(&a->archive, ENAMETOOLONG,
"Link contents too long");
ret = ARCHIVE_FAILED;
copy_length = V7TAR_linkname_size;
}
memcpy(h + V7TAR_linkname_offset, p, copy_length);
}
if (format_number(archive_entry_mode(entry) & 07777,
h + V7TAR_mode_offset, V7TAR_mode_size,
V7TAR_mode_max_size, strict)) {
archive_set_error(&a->archive, ERANGE,
"Numeric mode too large");
ret = ARCHIVE_FAILED;
}
if (format_number(archive_entry_uid(entry),
h + V7TAR_uid_offset, V7TAR_uid_size, V7TAR_uid_max_size, strict)) {
archive_set_error(&a->archive, ERANGE,
"Numeric user ID too large");
ret = ARCHIVE_FAILED;
}
if (format_number(archive_entry_gid(entry),
h + V7TAR_gid_offset, V7TAR_gid_size, V7TAR_gid_max_size, strict)) {
archive_set_error(&a->archive, ERANGE,
"Numeric group ID too large");
ret = ARCHIVE_FAILED;
}
if (format_number(archive_entry_size(entry),
h + V7TAR_size_offset, V7TAR_size_size,
V7TAR_size_max_size, strict)) {
archive_set_error(&a->archive, ERANGE,
"File size out of range");
ret = ARCHIVE_FAILED;
}
if (format_number(archive_entry_mtime(entry),
h + V7TAR_mtime_offset, V7TAR_mtime_size,
V7TAR_mtime_max_size, strict)) {
archive_set_error(&a->archive, ERANGE,
"File modification time too large");
ret = ARCHIVE_FAILED;
}
if (mytartype >= 0) {
h[V7TAR_typeflag_offset] = mytartype;
} else {
switch (archive_entry_filetype(entry)) {
case AE_IFREG: case AE_IFDIR:
break;
case AE_IFLNK:
h[V7TAR_typeflag_offset] = '2';
break;
case AE_IFCHR:
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"tar format cannot archive character device");
return (ARCHIVE_FAILED);
case AE_IFBLK:
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"tar format cannot archive block device");
return (ARCHIVE_FAILED);
case AE_IFIFO:
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"tar format cannot archive fifo");
return (ARCHIVE_FAILED);
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));
ret = ARCHIVE_FAILED;
}
}
checksum = 0;
for (i = 0; i < 512; i++)
checksum += 255 & (unsigned int)h[i];
format_octal(checksum, h + V7TAR_checksum_offset, 6);
/* Can't be pre-set in the template. */
h[V7TAR_checksum_offset + 6] = '\0';
return (ret);
}
/*
* Format a basic 512-byte "ustar" header.
*
* Returns -1 if format failed (due to field overflow).
* Note that this always formats as much of the header as possible.
* If "strict" is set to zero, it will extend numeric fields as
* necessary (overwriting terminators or using base-256 extensions).
*
* This is exported so that other 'tar' formats can use it.
*/
int
__archive_write_format_header_ustar(struct archive_write *a, char h[512],
struct archive_entry *entry, int tartype, int strict,
struct archive_string_conv *sconv)
{
unsigned int checksum;
int i, r, ret;
size_t copy_length;
const char *p, *pp;
int mytartype;
ret = 0;
mytartype = -1;
/*
* The "template header" already includes the "ustar"
* signature, various end-of-field markers and other required
* elements.
*/
memcpy(h, &template_header, 512);
/*
* Because the block is already null-filled, and strings
* are allowed to exactly fill their destination (without null),
* I use memcpy(dest, src, strlen()) here a lot to copy strings.
*/
r = archive_entry_pathname_l(entry, &pp, ©_length, sconv);
if (r != 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",
pp, archive_string_conversion_charset_name(sconv));
ret = ARCHIVE_WARN;
}
if (copy_length <= USTAR_name_size)
memcpy(h + USTAR_name_offset, pp, copy_length);
else {
/* Store in two pieces, splitting at a '/'. */
p = strchr(pp + copy_length - USTAR_name_size - 1, '/');
/*
* Look for the next '/' if we chose the first character
* as the separator. (ustar format doesn't permit
* an empty prefix.)
*/
if (p == pp)
p = strchr(p + 1, '/');
/* Fail if the name won't fit. */
if (!p) {
/* No separator. */
archive_set_error(&a->archive, ENAMETOOLONG,
"Pathname too long");
ret = ARCHIVE_FAILED;
} else if (p[1] == '\0') {
/*
* The only feasible separator is a final '/';
* this would result in a non-empty prefix and
* an empty name, which POSIX doesn't
* explicitly forbid, but it just feels wrong.
*/
archive_set_error(&a->archive, ENAMETOOLONG,
"Pathname too long");
ret = ARCHIVE_FAILED;
} else if (p > pp + USTAR_prefix_size) {
/* Prefix is too long. */
archive_set_error(&a->archive, ENAMETOOLONG,
"Pathname too long");
ret = ARCHIVE_FAILED;
} else {
/* Copy prefix and remainder to appropriate places */
memcpy(h + USTAR_prefix_offset, pp, p - pp);
memcpy(h + USTAR_name_offset, p + 1,
pp + copy_length - p - 1);
}
}
r = archive_entry_hardlink_l(entry, &p, ©_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",
p, archive_string_conversion_charset_name(sconv));
ret = ARCHIVE_WARN;
}
if (copy_length > 0)
mytartype = '1';
else {
r = archive_entry_symlink_l(entry, &p, ©_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",
p, archive_string_conversion_charset_name(sconv));
ret = ARCHIVE_WARN;
}
}
if (copy_length > 0) {
if (copy_length > USTAR_linkname_size) {
archive_set_error(&a->archive, ENAMETOOLONG,
"Link contents too long");
ret = ARCHIVE_FAILED;
copy_length = USTAR_linkname_size;
}
memcpy(h + USTAR_linkname_offset, p, copy_length);
}
r = archive_entry_uname_l(entry, &p, ©_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",
p, archive_string_conversion_charset_name(sconv));
ret = ARCHIVE_WARN;
}
if (copy_length > 0) {
if (copy_length > USTAR_uname_size) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Username too long");
ret = ARCHIVE_FAILED;
copy_length = USTAR_uname_size;
}
memcpy(h + USTAR_uname_offset, p, copy_length);
}
r = archive_entry_gname_l(entry, &p, ©_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",
p, archive_string_conversion_charset_name(sconv));
ret = ARCHIVE_WARN;
}
if (copy_length > 0) {
if (strlen(p) > USTAR_gname_size) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Group name too long");
ret = ARCHIVE_FAILED;
copy_length = USTAR_gname_size;
}
memcpy(h + USTAR_gname_offset, p, copy_length);
}
if (format_number(archive_entry_mode(entry) & 07777,
h + USTAR_mode_offset, USTAR_mode_size, USTAR_mode_max_size, strict)) {
archive_set_error(&a->archive, ERANGE,
"Numeric mode too large");
ret = ARCHIVE_FAILED;
}
if (format_number(archive_entry_uid(entry),
h + USTAR_uid_offset, USTAR_uid_size, USTAR_uid_max_size, strict)) {
archive_set_error(&a->archive, ERANGE,
"Numeric user ID too large");
ret = ARCHIVE_FAILED;
}
if (format_number(archive_entry_gid(entry),
h + USTAR_gid_offset, USTAR_gid_size, USTAR_gid_max_size, strict)) {
archive_set_error(&a->archive, ERANGE,
"Numeric group ID too large");
ret = ARCHIVE_FAILED;
}
if (format_number(archive_entry_size(entry),
h + USTAR_size_offset, USTAR_size_size, USTAR_size_max_size, strict)) {
archive_set_error(&a->archive, ERANGE,
"File size out of range");
ret = ARCHIVE_FAILED;
}
if (format_number(archive_entry_mtime(entry),
h + USTAR_mtime_offset, USTAR_mtime_size, USTAR_mtime_max_size, strict)) {
archive_set_error(&a->archive, ERANGE,
"File modification time too large");
ret = ARCHIVE_FAILED;
}
if (archive_entry_filetype(entry) == AE_IFBLK
|| archive_entry_filetype(entry) == AE_IFCHR) {
if (format_number(archive_entry_rdevmajor(entry),
h + USTAR_rdevmajor_offset, USTAR_rdevmajor_size,
USTAR_rdevmajor_max_size, strict)) {
archive_set_error(&a->archive, ERANGE,
"Major device number too large");
ret = ARCHIVE_FAILED;
}
if (format_number(archive_entry_rdevminor(entry),
h + USTAR_rdevminor_offset, USTAR_rdevminor_size,
USTAR_rdevminor_max_size, strict)) {
archive_set_error(&a->archive, ERANGE,
"Minor device number too large");
ret = ARCHIVE_FAILED;
}
}
if (tartype >= 0) {
h[USTAR_typeflag_offset] = tartype;
} else if (mytartype >= 0) {
h[USTAR_typeflag_offset] = mytartype;
} else {
switch (archive_entry_filetype(entry)) {
case AE_IFREG: h[USTAR_typeflag_offset] = '0' ; break;
case AE_IFLNK: h[USTAR_typeflag_offset] = '2' ; break;
case AE_IFCHR: h[USTAR_typeflag_offset] = '3' ; break;
case AE_IFBLK: h[USTAR_typeflag_offset] = '4' ; break;
case AE_IFDIR: h[USTAR_typeflag_offset] = '5' ; break;
case AE_IFIFO: h[USTAR_typeflag_offset] = '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));
ret = ARCHIVE_FAILED;
}
}
checksum = 0;
for (i = 0; i < 512; i++)
checksum += 255 & (unsigned int)h[i];
h[USTAR_checksum_offset + 6] = '\0'; /* Can't be pre-set in the template. */
/* h[USTAR_checksum_offset + 7] = ' '; */ /* This is pre-set in the template. */
format_octal(checksum, h + USTAR_checksum_offset, 6);
return (ret);
}
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);
}