#ifdef HAVE_SYS_WAIT_H
#include <sys/wait.h>
#endif
+#ifdef HAVE_ERRNO_H
+#include <errno.h>
+#endif
#ifdef HAVE_LIMITS_H
#include <limits.h>
#endif
static int _archive_write_finish_entry(struct archive *);
static ssize_t _archive_write_data(struct archive *, const void *, size_t);
+struct archive_none {
+ size_t buffer_size;
+ size_t avail;
+ char *buffer;
+ char *next;
+};
+
static struct archive_vtable *
archive_write_vtable(void)
{
archive_write_client_open(struct archive_write_filter *f)
{
struct archive_write *a = (struct archive_write *)f->archive;
+ struct archive_none *state;
+ void *buffer;
+ size_t buffer_size;
+
+ f->bytes_per_block = archive_write_get_bytes_per_block(f->archive);
+ f->bytes_in_last_block =
+ archive_write_get_bytes_in_last_block(f->archive);
+ buffer_size = f->bytes_per_block;
+
+ state = (struct archive_none *)calloc(1, sizeof(*state));
+ buffer = (char *)malloc(buffer_size);
+ if (state == NULL || buffer == NULL) {
+ free(state);
+ free(buffer);
+ archive_set_error(f->archive, ENOMEM,
+ "Can't allocate data for output buffering");
+ return (ARCHIVE_FATAL);
+ }
+
+ state->buffer_size = buffer_size;
+ state->buffer = buffer;
+ state->next = state->buffer;
+ state->avail = state->buffer_size;
+ f->data = state;
+
if (a->client_opener == NULL)
return (ARCHIVE_OK);
- return (a->client_opener(f->archive, f->data));
+ return (a->client_opener(f->archive, a->client_data));
}
static int
const void *_buff, size_t length)
{
struct archive_write *a = (struct archive_write *)f->archive;
- const char *buff = _buff;
-
- while (length > 0) {
- ssize_t written
- = (a->client_writer(f->archive, f->data, buff, length));
- if (written < 0)
- return ((int)written);
- if (written == 0)
- return (ARCHIVE_FATAL);
- buff += written;
- length -= written;
- }
- return (ARCHIVE_OK);
+ struct archive_none *state = (struct archive_none *)f->data;
+ const char *buff = (const char *)_buff;
+ ssize_t remaining, to_copy;
+ ssize_t bytes_written;
+
+ remaining = length;
+
+ /*
+ * If there is no buffer for blocking, just pass the data
+ * straight through to the client write callback. In
+ * particular, this supports "no write delay" operation for
+ * special applications. Just set the block size to zero.
+ */
+ if (state->buffer_size == 0) {
+ while (remaining > 0) {
+ bytes_written = (a->client_writer)(&a->archive,
+ a->client_data, buff, remaining);
+ if (bytes_written <= 0)
+ return (ARCHIVE_FATAL);
+ remaining -= bytes_written;
+ buff += bytes_written;
+ }
+ return (ARCHIVE_OK);
+ }
+
+ /* If the copy buffer isn't empty, try to fill it. */
+ if (state->avail < state->buffer_size) {
+ /* If buffer is not empty... */
+ /* ... copy data into buffer ... */
+ to_copy = (remaining > state->avail) ?
+ state->avail : remaining;
+ memcpy(state->next, buff, to_copy);
+ state->next += to_copy;
+ state->avail -= to_copy;
+ buff += to_copy;
+ remaining -= to_copy;
+ /* ... if it's full, write it out. */
+ if (state->avail == 0) {
+ bytes_written = (a->client_writer)(&a->archive,
+ a->client_data, state->buffer, state->buffer_size);
+ if (bytes_written <= 0)
+ return (ARCHIVE_FATAL);
+ /* XXX TODO: if bytes_written < state->buffer_size */
+ state->next = state->buffer;
+ state->avail = state->buffer_size;
+ }
+ }
+
+ while (remaining > state->buffer_size) {
+ /* Write out full blocks directly to client. */
+ bytes_written = (a->client_writer)(&a->archive,
+ a->client_data, buff, state->buffer_size);
+ if (bytes_written <= 0)
+ return (ARCHIVE_FATAL);
+ buff += bytes_written;
+ remaining -= bytes_written;
+ }
+
+ if (remaining > 0) {
+ /* Copy last bit into copy buffer. */
+ memcpy(state->next, buff, remaining);
+ state->next += remaining;
+ state->avail -= remaining;
+ }
+ return (ARCHIVE_OK);
}
static int
archive_write_client_close(struct archive_write_filter *f)
{
struct archive_write *a = (struct archive_write *)f->archive;
- if (a->client_closer == NULL)
- return (ARCHIVE_OK);
- return (a->client_closer(f->archive, f->data));
+ struct archive_none *state = (struct archive_none *)f->data;
+ ssize_t block_length;
+ ssize_t target_block_length;
+ ssize_t bytes_written;
+ int ret = ARCHIVE_OK;
+
+ /* If there's pending data, pad and write the last block */
+ if (state->next != state->buffer) {
+ block_length = state->buffer_size - state->avail;
+
+ /* Tricky calculation to determine size of last block */
+ if (a->bytes_in_last_block <= 0)
+ /* Default or Zero: pad to full block */
+ target_block_length = a->bytes_per_block;
+ else
+ /* Round to next multiple of bytes_in_last_block. */
+ target_block_length = a->bytes_in_last_block *
+ ( (block_length + a->bytes_in_last_block - 1) /
+ a->bytes_in_last_block);
+ if (target_block_length > a->bytes_per_block)
+ target_block_length = a->bytes_per_block;
+ if (block_length < target_block_length) {
+ memset(state->next, 0,
+ target_block_length - block_length);
+ block_length = target_block_length;
+ }
+ bytes_written = (a->client_writer)(&a->archive,
+ a->client_data, state->buffer, block_length);
+ ret = bytes_written <= 0 ? ARCHIVE_FATAL : ARCHIVE_OK;
+ }
+ free(state->buffer);
+ free(state);
+ a->client_data = NULL;
+ return (ret);
}
/*
a->client_writer = writer;
a->client_opener = opener;
a->client_closer = closer;
+ a->client_data = client_data;
client_filter = __archive_write_allocate_filter(_a);
- client_filter->data = client_data;
client_filter->open = archive_write_client_open;
client_filter->write = archive_write_client_write;
client_filter->close = archive_write_client_close;
archive_compressor_bzip2_close(struct archive_write_filter *f)
{
struct private_data *data = (struct private_data *)f->data;
- ssize_t bytes_written;
- int ret;
-
- if (data == NULL)
- return (ARCHIVE_OK);
+ int ret, r1;
/* Finish compression cycle. */
ret = drive_compressor(f, data, 1);
if (ret == ARCHIVE_OK) {
/* Write the last block */
- bytes_written = __archive_write_filter(f->next_filter,
+ ret = __archive_write_filter(f->next_filter,
data->compressed,
data->compressed_buffer_size - data->stream.avail_out);
- if (bytes_written <= 0)
- ret = ARCHIVE_FATAL;
}
switch (BZ2_bzCompressEnd(&(data->stream))) {
"Failed to clean up compressor");
ret = ARCHIVE_FATAL;
}
- return (ARCHIVE_OK);
+
+ r1 = __archive_write_close_filter(f->next_filter);
+ return (r1 < ret ? r1 : ret);
}
static int
ret = __archive_write_filter(f->next_filter,
state->compressed, state->compressed_offset);
cleanup:
+ ret = __archive_write_close_filter(f->next_filter);
free(state->compressed);
free(state);
return (ret);
{
unsigned char trailer[8];
struct private_data *data = (struct private_data *)f->data;
- int ret;
-
- ret = 0;
- if (data != NULL) {
- /* Finish compression cycle */
- ret = drive_compressor(f, data, 1);
- if (ret != ARCHIVE_OK)
- goto cleanup;
+ int ret, r1;
+ /* Finish compression cycle */
+ ret = drive_compressor(f, data, 1);
+ if (ret == ARCHIVE_OK) {
/* Write the last compressed data. */
ret = __archive_write_filter(f->next_filter,
data->compressed,
data->compressed_buffer_size - data->stream.avail_out);
- if (ret != ARCHIVE_OK) {
- ret = ARCHIVE_FATAL;
- goto cleanup;
- }
-
+ }
+ if (ret == ARCHIVE_OK) {
/* Build and write out 8-byte trailer. */
trailer[0] = (data->crc)&0xff;
trailer[1] = (data->crc >> 8)&0xff;
trailer[6] = (data->total_in >> 16)&0xff;
trailer[7] = (data->total_in >> 24)&0xff;
ret = __archive_write_filter(f->next_filter, trailer, 8);
- if (ret != ARCHIVE_OK)
- ret = ARCHIVE_FATAL;
+ }
- cleanup:
- switch (deflateEnd(&(data->stream))) {
- case Z_OK:
- break;
- default:
- archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
- "Failed to clean up compressor");
- ret = ARCHIVE_FATAL;
- }
+ switch (deflateEnd(&(data->stream))) {
+ case Z_OK:
+ break;
+ default:
+ archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
+ "Failed to clean up compressor");
+ ret = ARCHIVE_FATAL;
}
- return (ret);
+ r1 = __archive_write_close_filter(f->next_filter);
+ return (r1 < ret ? r1 : ret);
}
static int
/*-
- * Copyright (c) 2003-2007 Tim Kientzle
+ * Copyright (c) 2003-2010 Tim Kientzle
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
#include "archive_platform.h"
__FBSDID("$FreeBSD: head/lib/libarchive/archive_write_set_compression_none.c 201080 2009-12-28 02:03:54Z kientzle $");
-#ifdef HAVE_ERRNO_H
-#include <errno.h>
-#endif
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
-#ifdef HAVE_STRING_H
-#include <string.h>
-#endif
-
#include "archive.h"
-#include "archive_private.h"
-#include "archive_write_private.h"
-
int
archive_write_set_compression_none(struct archive *a)
{
- __archive_write_filters_free(a);
- return (archive_write_add_filter_none(a));
-}
-
-
-static int archive_compressor_none_open(struct archive_write_filter *);
-static int archive_compressor_none_write(struct archive_write_filter *,
- const void *, size_t);
-static int archive_compressor_none_close(struct archive_write_filter *);
-static int archive_compressor_none_free(struct archive_write_filter *);
-
-struct archive_none {
- char *buffer;
- ssize_t buffer_size;
- char *next; /* Current insert location */
- ssize_t avail; /* Free space left in buffer */
-};
-
-/*
- * TODO: A little refactoring will turn this into a true no-op.
- */
-int
-archive_write_add_filter_none(struct archive *_a)
-{
- struct archive_write *a = (struct archive_write *)_a;
- struct archive_write_filter *f = __archive_write_allocate_filter(_a);
- __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
- ARCHIVE_STATE_NEW, "archive_write_set_compression_none");
- f->open = &archive_compressor_none_open;
- f->code = ARCHIVE_COMPRESSION_NONE;
- f->name = "none";
-
- return (ARCHIVE_OK);
-}
-
-/*
- * Setup callback.
- */
-static int
-archive_compressor_none_open(struct archive_write_filter *f)
-{
- int ret;
- struct archive_none *state;
-
- ret = __archive_write_open_filter(f->next_filter);
- if (ret != 0)
- return (ret);
-
- f->bytes_per_block = archive_write_get_bytes_per_block(f->archive);
- f->bytes_in_last_block = archive_write_get_bytes_in_last_block(f->archive);
-
- state = (struct archive_none *)calloc(1, sizeof(*state));
- if (state == NULL) {
- archive_set_error(f->archive, ENOMEM,
- "Can't allocate data for output buffering");
- return (ARCHIVE_FATAL);
- }
-
- state->buffer_size = f->bytes_per_block;
- if (state->buffer_size != 0) {
- state->buffer = (char *)malloc(state->buffer_size);
- if (state->buffer == NULL) {
- archive_set_error(f->archive, ENOMEM,
- "Can't allocate output buffer");
- free(state);
- return (ARCHIVE_FATAL);
- }
- }
-
- state->next = state->buffer;
- state->avail = state->buffer_size;
-
- f->data = state;
- f->write = archive_compressor_none_write;
- f->close = archive_compressor_none_close;
- f->free = archive_compressor_none_free;
+ (void)a; /* UNUSED */
return (ARCHIVE_OK);
}
-/*
- * Write data to the stream.
- */
-static int
-archive_compressor_none_write(struct archive_write_filter *f,
- const void *vbuff, size_t length)
-{
- struct archive_none *state = (struct archive_none *)f->data;
- const char *buff;
- ssize_t remaining, to_copy;
- int ret;
-
- /*
- * If there is no buffer for blocking, just pass the data
- * straight through to the client write callback. In
- * particular, this supports "no write delay" operation for
- * special applications. Just set the block size to zero.
- */
- if (state->buffer_size == 0)
- return (__archive_write_filter(f->next_filter,
- vbuff, length));
-
- buff = (const char *)vbuff;
- remaining = length;
-
- /* If the copy buffer isn't empty, try to fill it. */
- if (state->avail < state->buffer_size) {
- /* If buffer is not empty... */
- /* ... copy data into buffer ... */
- to_copy = (remaining > state->avail) ?
- state->avail : remaining;
- memcpy(state->next, buff, to_copy);
- state->next += to_copy;
- state->avail -= to_copy;
- buff += to_copy;
- remaining -= to_copy;
- /* ... if it's full, write it out. */
- if (state->avail == 0) {
- ret = __archive_write_filter(f->next_filter,
- state->buffer, state->buffer_size);
- if (ret != ARCHIVE_OK)
- return (ARCHIVE_FATAL);
- state->next = state->buffer;
- state->avail = state->buffer_size;
- }
- }
-
- /* Write out full blocks directly to client. */
- while (remaining > state->buffer_size) {
- ret = __archive_write_filter(f->next_filter,
- buff, state->buffer_size);
- if (ret != ARCHIVE_OK)
- return (ARCHIVE_FATAL);
- buff += state->buffer_size;
- remaining -= state->buffer_size;
- }
-
- if (remaining > 0) {
- /* Copy last bit into copy buffer. */
- memcpy(state->next, buff, remaining);
- state->next += remaining;
- state->avail -= remaining;
- }
-
- return (ARCHIVE_OK);
-}
-
-
-/*
- * Finish the compression.
- */
-static int
-archive_compressor_none_close(struct archive_write_filter *f)
-{
- struct archive_none *state = (struct archive_none *)f->data;
- ssize_t block_length;
- ssize_t target_block_length;
- int ret;
-
- ret = ARCHIVE_OK;
-
- /* If there's pending data, pad and write the last block */
- if (state->next != state->buffer) {
- block_length = state->buffer_size - state->avail;
-
- /* Tricky calculation to determine size of last block */
- if (f->bytes_in_last_block <= 0)
- /* Default or Zero: pad to full block */
- target_block_length = f->bytes_per_block;
- else
- /* Round to next multiple of bytes_in_last_block. */
- target_block_length = f->bytes_in_last_block *
- ( (block_length + f->bytes_in_last_block - 1) /
- f->bytes_in_last_block);
- if (target_block_length > f->bytes_per_block)
- target_block_length = f->bytes_per_block;
- if (block_length < target_block_length) {
- memset(state->next, 0,
- target_block_length - block_length);
- block_length = target_block_length;
- }
- ret = __archive_write_filter(f->next_filter,
- state->buffer, block_length);
- }
- if (state->buffer)
- free(state->buffer);
- free(state);
- f->data = NULL;
-
- return (ret);
-}
-
-static int
-archive_compressor_none_free(struct archive_write_filter *f)
+int
+archive_write_add_filter_none(struct archive *a)
{
- (void)f; /* UNUSED */
+ (void)a; /* UNUSED */
return (ARCHIVE_OK);
}
archive_compressor_program_close(struct archive_write_filter *f)
{
struct private_data *data = (struct private_data *)f->data;
- int ret, status;
+ int ret, r1, status;
ssize_t bytes_read;
ret = 0;
"Filter exited with failure.");
ret = ARCHIVE_FATAL;
}
- return (ret);
+ r1 = __archive_write_close_filter(f->next_filter);
+ return (r1 < ret ? r1 : ret);
}
static int
archive_compressor_xz_close(struct archive_write_filter *f)
{
struct private_data *data = (struct private_data *)f->data;
- int ret;
+ int ret, r1;
- if (data == NULL)
- return (ARCHIVE_OK);
ret = drive_compressor(f, data, 1);
if (ret == ARCHIVE_OK) {
ret = __archive_write_filter(f->next_filter,
data->compressed_buffer_size - data->stream.avail_out);
}
lzma_end(&(data->stream));
- return (ret);
+ r1 = __archive_write_close_filter(f->next_filter);
+ return (r1 < ret ? r1 : ret);
}
static int
projects / thirdparty / libarchive.git / commitdiff
