/*
* Finish the compression...
*/
static int
archive_compressor_xz_close(struct archive_write_filter *f)
{
struct private_data *data = (struct private_data *)f->data;
int ret, r1;
ret = drive_compressor(f, data, 1);
if (ret == ARCHIVE_OK) {
data->total_out +=
data->compressed_buffer_size - data->stream.avail_out;
ret = __archive_write_filter(f->next_filter,
data->compressed,
data->compressed_buffer_size - data->stream.avail_out);
if (f->code == ARCHIVE_FILTER_LZIP && ret == ARCHIVE_OK) {
archive_le32enc(data->compressed, data->crc32);
archive_le64enc(data->compressed+4, data->total_in);
archive_le64enc(data->compressed+12, data->total_out + 20);
ret = __archive_write_filter(f->next_filter,
data->compressed, 20);
}
}
lzma_end(&(data->stream));
r1 = __archive_write_close_filter(f->next_filter);
return (r1 < ret ? r1 : ret);
}
/*
* Finish the compression.
*/
static int
archive_compressor_bzip2_close(struct archive_write_filter *f)
{
struct private_data *data = (struct private_data *)f->data;
int ret, r1;
/* Finish compression cycle. */
ret = drive_compressor(f, data, 1);
if (ret == ARCHIVE_OK) {
/* Write the last block */
ret = __archive_write_filter(f->next_filter,
data->compressed,
data->compressed_buffer_size - data->stream.avail_out);
}
switch (BZ2_bzCompressEnd(&(data->stream))) {
case BZ_OK:
break;
default:
archive_set_error(f->archive, ARCHIVE_ERRNO_PROGRAMMER,
"Failed to clean up compressor");
ret = ARCHIVE_FATAL;
}
r1 = __archive_write_close_filter(f->next_filter);
return (r1 < ret ? r1 : ret);
}
/*
* Finish the compression.
*/
static int
archive_filter_lz4_close(struct archive_write_filter *f)
{
struct private_data *data = (struct private_data *)f->data;
int ret, r1;
/* Finish compression cycle. */
ret = (int)lz4_write_one_block(f, NULL, 0);
if (ret >= 0) {
/*
* Write the last block and the end of the stream data.
*/
/* Write End Of Stream. */
memset(data->out, 0, 4); data->out += 4;
/* Write Stream checksum if needed. */
if (data->stream_checksum) {
unsigned int checksum;
checksum = __archive_xxhash.XXH32_digest(
data->xxh32_state);
data->xxh32_state = NULL;
archive_le32enc(data->out, checksum);
data->out += 4;
}
ret = __archive_write_filter(f->next_filter,
data->out_buffer, data->out - data->out_buffer);
}
r1 = __archive_write_close_filter(f->next_filter);
return (r1 < ret ? r1 : ret);
}
/*
* Utility function to push input data through compressor,
* writing full output blocks as necessary.
*
* Note that this handles both the regular write case (finishing ==
* false) and the end-of-archive case (finishing == true).
*/
static int
drive_compressor(struct archive_write_filter *f,
struct private_data *data, int finishing)
{
int ret;
for (;;) {
if (data->stream.avail_out == 0) {
data->total_out += data->compressed_buffer_size;
ret = __archive_write_filter(f->next_filter,
data->compressed,
data->compressed_buffer_size);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
data->stream.next_out = data->compressed;
data->stream.avail_out = data->compressed_buffer_size;
}
/* If there's nothing to do, we're done. */
if (!finishing && data->stream.avail_in == 0)
return (ARCHIVE_OK);
ret = lzma_code(&(data->stream),
finishing ? LZMA_FINISH : LZMA_RUN );
switch (ret) {
case LZMA_OK:
/* In non-finishing case, check if compressor
* consumed everything */
if (!finishing && data->stream.avail_in == 0)
return (ARCHIVE_OK);
/* In finishing case, this return always means
* there's more work */
break;
case LZMA_STREAM_END:
/* This return can only occur in finishing case. */
if (finishing)
return (ARCHIVE_OK);
archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
"lzma compression data error");
return (ARCHIVE_FATAL);
case LZMA_MEMLIMIT_ERROR:
archive_set_error(f->archive, ENOMEM,
"lzma compression error: "
"%ju MiB would have been needed",
(uintmax_t)((lzma_memusage(&(data->stream))
+ 1024 * 1024 -1)
/ (1024 * 1024)));
return (ARCHIVE_FATAL);
default:
/* Any other return value indicates an error. */
archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
"lzma compression failed:"
" lzma_code() call returned status %d",
ret);
return (ARCHIVE_FATAL);
}
}
}
/*
* Finish the compression...
*/
static int
archive_compressor_program_close(struct archive_write_filter *f)
{
struct private_data *data = (struct private_data *)f->data;
int ret, r1, status;
ssize_t bytes_read;
ret = 0;
close(data->child_stdin);
data->child_stdin = -1;
fcntl(data->child_stdout, F_SETFL, 0);
for (;;) {
do {
bytes_read = read(data->child_stdout,
data->child_buf + data->child_buf_avail,
data->child_buf_len - data->child_buf_avail);
} while (bytes_read == -1 && errno == EINTR);
if (bytes_read == 0 || (bytes_read == -1 && errno == EPIPE))
break;
if (bytes_read == -1) {
archive_set_error(f->archive, errno,
"Read from filter failed unexpectedly.");
ret = ARCHIVE_FATAL;
goto cleanup;
}
data->child_buf_avail += bytes_read;
ret = __archive_write_filter(f->next_filter,
data->child_buf, data->child_buf_avail);
if (ret != ARCHIVE_OK) {
ret = ARCHIVE_FATAL;
goto cleanup;
}
data->child_buf_avail = 0;
}
cleanup:
/* Shut down the child. */
if (data->child_stdin != -1)
close(data->child_stdin);
if (data->child_stdout != -1)
close(data->child_stdout);
while (waitpid(data->child, &status, 0) == -1 && errno == EINTR)
continue;
if (status != 0) {
archive_set_error(f->archive, EIO,
"Filter exited with failure.");
ret = ARCHIVE_FATAL;
}
r1 = __archive_write_close_filter(f->next_filter);
return (r1 < ret ? r1 : ret);
}
/*
* Utility function to push input data through compressor, writing
* full output blocks as necessary.
*
* Note that this handles both the regular write case (finishing ==
* false) and the end-of-archive case (finishing == true).
*/
static int
drive_compressor(struct archive_write_filter *f,
struct private_data *data, int finishing)
{
int ret;
for (;;) {
if (data->stream.avail_out == 0) {
ret = __archive_write_filter(f->next_filter,
data->compressed,
data->compressed_buffer_size);
if (ret != ARCHIVE_OK) {
/* TODO: Handle this write failure */
return (ARCHIVE_FATAL);
}
data->stream.next_out = data->compressed;
data->stream.avail_out = data->compressed_buffer_size;
}
/* If there's nothing to do, we're done. */
if (!finishing && data->stream.avail_in == 0)
return (ARCHIVE_OK);
ret = BZ2_bzCompress(&(data->stream),
finishing ? BZ_FINISH : BZ_RUN);
switch (ret) {
case BZ_RUN_OK:
/* In non-finishing case, did compressor
* consume everything? */
if (!finishing && data->stream.avail_in == 0)
return (ARCHIVE_OK);
break;
case BZ_FINISH_OK: /* Finishing: There's more work to do */
break;
case BZ_STREAM_END: /* Finishing: all done */
/* Only occurs in finishing case */
return (ARCHIVE_OK);
default:
/* Any other return value indicates an error */
archive_set_error(f->archive,
ARCHIVE_ERRNO_PROGRAMMER,
"Bzip2 compression failed;"
" BZ2_bzCompress() returned %d",
ret);
return (ARCHIVE_FATAL);
}
}
}
/*
* Write data to the out stream.
*
* Returns ARCHIVE_OK if all data written, error otherwise.
*/
static int
archive_filter_lz4_write(struct archive_write_filter *f,
const void *buff, size_t length)
{
struct private_data *data = (struct private_data *)f->data;
int ret = ARCHIVE_OK;
const char *p;
size_t remaining;
ssize_t size;
/* If we haven't written a stream descriptor, we have to do it first. */
if (!data->header_written) {
ret = lz4_write_stream_descriptor(f);
if (ret != ARCHIVE_OK)
return (ret);
data->header_written = 1;
}
/* Update statistics */
data->total_in += length;
p = (const char *)buff;
remaining = length;
while (remaining) {
size_t l;
/* Compress input data to output buffer */
size = lz4_write_one_block(f, p, remaining);
if (size < ARCHIVE_OK)
return (ARCHIVE_FATAL);
l = data->out - data->out_buffer;
if (l >= data->out_block_size) {
ret = __archive_write_filter(f->next_filter,
data->out_buffer, data->out_block_size);
l -= data->out_block_size;
memcpy(data->out_buffer,
data->out_buffer + data->out_block_size, l);
data->out = data->out_buffer + l;
if (ret < ARCHIVE_WARN)
break;
}
p += size;
remaining -= size;
}
return (ret);
}
static int
output_byte(struct archive_write_filter *f, unsigned char c)
{
struct private_data *state = f->data;
state->compressed[state->compressed_offset++] = c;
++state->out_count;
if (state->compressed_buffer_size == state->compressed_offset) {
int ret = __archive_write_filter(f->next_filter,
state->compressed, state->compressed_buffer_size);
if (ret != ARCHIVE_OK)
return ARCHIVE_FATAL;
state->compressed_offset = 0;
}
return ARCHIVE_OK;
}
static ssize_t
child_write(struct archive_write_filter *f,
struct archive_write_program_data *data, const char *buf, size_t buf_len)
{
ssize_t ret;
if (data->child_stdin == -1)
return (-1);
if (buf_len == 0)
return (-1);
for (;;) {
do {
ret = write(data->child_stdin, buf, buf_len);
} while (ret == -1 && errno == EINTR);
if (ret > 0)
return (ret);
if (ret == 0) {
close(data->child_stdin);
data->child_stdin = -1;
fcntl(data->child_stdout, F_SETFL, 0);
return (0);
}
if (ret == -1 && errno != EAGAIN)
return (-1);
if (data->child_stdout == -1) {
fcntl(data->child_stdin, F_SETFL, 0);
__archive_check_child(data->child_stdin,
data->child_stdout);
continue;
}
do {
ret = read(data->child_stdout,
data->child_buf + data->child_buf_avail,
data->child_buf_len - data->child_buf_avail);
} while (ret == -1 && errno == EINTR);
if (ret == 0 || (ret == -1 && errno == EPIPE)) {
close(data->child_stdout);
data->child_stdout = -1;
fcntl(data->child_stdin, F_SETFL, 0);
continue;
}
if (ret == -1 && errno == EAGAIN) {
__archive_check_child(data->child_stdin,
data->child_stdout);
continue;
}
if (ret == -1)
return (-1);
data->child_buf_avail += ret;
ret = __archive_write_filter(f->next_filter,
data->child_buf, data->child_buf_avail);
if (ret != ARCHIVE_OK)
return (-1);
data->child_buf_avail = 0;
}
}
/*
* Finish the filtering...
*/
int
__archive_write_program_close(struct archive_write_filter *f,
struct archive_write_program_data *data)
{
int ret, r1, status;
ssize_t bytes_read;
if (data->child == 0)
return __archive_write_close_filter(f->next_filter);
ret = 0;
close(data->child_stdin);
data->child_stdin = -1;
fcntl(data->child_stdout, F_SETFL, 0);
for (;;) {
do {
bytes_read = read(data->child_stdout,
data->child_buf + data->child_buf_avail,
data->child_buf_len - data->child_buf_avail);
} while (bytes_read == -1 && errno == EINTR);
if (bytes_read == 0 || (bytes_read == -1 && errno == EPIPE))
break;
if (bytes_read == -1) {
archive_set_error(f->archive, errno,
"Error reading from program: %s", data->program_name);
ret = ARCHIVE_FATAL;
goto cleanup;
}
data->child_buf_avail += bytes_read;
ret = __archive_write_filter(f->next_filter,
data->child_buf, data->child_buf_avail);
if (ret != ARCHIVE_OK) {
ret = ARCHIVE_FATAL;
goto cleanup;
}
data->child_buf_avail = 0;
}
cleanup:
/* Shut down the child. */
if (data->child_stdin != -1)
close(data->child_stdin);
if (data->child_stdout != -1)
close(data->child_stdout);
while (waitpid(data->child, &status, 0) == -1 && errno == EINTR)
continue;
#if defined(_WIN32) && !defined(__CYGWIN__)
CloseHandle(data->child);
#endif
data->child = 0;
if (status != 0) {
archive_set_error(f->archive, EIO,
"Error closing program: %s", data->program_name);
ret = ARCHIVE_FATAL;
}
r1 = __archive_write_close_filter(f->next_filter);
return (r1 < ret ? r1 : ret);
}
int
__archive_write_output(struct archive_write *a, const void *buff, size_t length)
{
return (__archive_write_filter(a->filter_first, buff, length));
}
static ssize_t
child_write(struct archive_write_filter *f, const char *buf, size_t buf_len)
{
struct private_data *data = f->data;
ssize_t ret;
if (data->child_stdin == -1)
return (-1);
if (buf_len == 0)
return (-1);
restart_write:
do {
ret = write(data->child_stdin, buf, buf_len);
} while (ret == -1 && errno == EINTR);
if (ret > 0)
return (ret);
if (ret == 0) {
close(data->child_stdin);
data->child_stdin = -1;
fcntl(data->child_stdout, F_SETFL, 0);
return (0);
}
if (ret == -1 && errno != EAGAIN)
return (-1);
if (data->child_stdout == -1) {
fcntl(data->child_stdin, F_SETFL, 0);
__archive_check_child(data->child_stdin, data->child_stdout);
goto restart_write;
}
do {
ret = read(data->child_stdout,
data->child_buf + data->child_buf_avail,
data->child_buf_len - data->child_buf_avail);
} while (ret == -1 && errno == EINTR);
if (ret == 0 || (ret == -1 && errno == EPIPE)) {
close(data->child_stdout);
data->child_stdout = -1;
fcntl(data->child_stdin, F_SETFL, 0);
goto restart_write;
}
if (ret == -1 && errno == EAGAIN) {
__archive_check_child(data->child_stdin, data->child_stdout);
goto restart_write;
}
if (ret == -1)
return (-1);
data->child_buf_avail += ret;
ret = __archive_write_filter(f->next_filter,
data->child_buf, data->child_buf_avail);
if (ret <= 0)
return (-1);
if ((size_t)ret < data->child_buf_avail) {
memmove(data->child_buf, data->child_buf + ret,
data->child_buf_avail - ret);
}
data->child_buf_avail -= ret;
goto restart_write;
}
