| /*- |
| * Copyright (c) 2007 Joerg Sonnenberger |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "archive_platform.h" |
| __FBSDID("$FreeBSD: head/lib/libarchive/archive_write_set_compression_program.c 201104 2009-12-28 03:14:30Z kientzle $"); |
| |
| #ifdef HAVE_SYS_WAIT_H |
| # include <sys/wait.h> |
| #endif |
| #ifdef HAVE_ERRNO_H |
| # include <errno.h> |
| #endif |
| #ifdef HAVE_FCNTL_H |
| # include <fcntl.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" |
| |
| #if ARCHIVE_VERSION_NUMBER < 4000000 |
| int |
| archive_write_set_compression_program(struct archive *a, const char *cmd) |
| { |
| __archive_write_filters_free(a); |
| return (archive_write_add_filter_program(a, cmd)); |
| } |
| #endif |
| |
| /* This capability is only available on POSIX systems. */ |
| #if (!defined(HAVE_PIPE) || !defined(HAVE_FCNTL) || \ |
| !(defined(HAVE_FORK) || defined(HAVE_VFORK))) && (!defined(_WIN32) || defined(__CYGWIN__)) |
| |
| /* |
| * On non-Posix systems, allow the program to build, but choke if |
| * this function is actually invoked. |
| */ |
| int |
| archive_write_add_filter_program(struct archive *_a, const char *cmd) |
| { |
| archive_set_error(_a, -1, |
| "External compression programs not supported on this platform"); |
| return (ARCHIVE_FATAL); |
| } |
| |
| #else |
| |
| #include "filter_fork.h" |
| |
| struct private_data { |
| char *cmd; |
| char *description; |
| pid_t child; |
| int child_stdin, child_stdout; |
| |
| char *child_buf; |
| size_t child_buf_len, child_buf_avail; |
| }; |
| |
| static int archive_compressor_program_open(struct archive_write_filter *); |
| static int archive_compressor_program_write(struct archive_write_filter *, |
| const void *, size_t); |
| static int archive_compressor_program_close(struct archive_write_filter *); |
| static int archive_compressor_program_free(struct archive_write_filter *); |
| |
| /* |
| * Add a filter to this write handle that passes all data through an |
| * external program. |
| */ |
| int |
| archive_write_add_filter_program(struct archive *_a, const char *cmd) |
| { |
| struct archive_write_filter *f = __archive_write_allocate_filter(_a); |
| struct archive_write *a = (struct archive_write *)_a; |
| struct private_data *data; |
| static const char *prefix = "Program: "; |
| archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, |
| ARCHIVE_STATE_NEW, "archive_write_add_filter_program"); |
| data = calloc(1, sizeof(*data)); |
| if (data == NULL) { |
| archive_set_error(&a->archive, ENOMEM, "Out of memory"); |
| return (ARCHIVE_FATAL); |
| } |
| data->cmd = strdup(cmd); |
| data->description = (char *)malloc(strlen(prefix) + strlen(cmd) + 1); |
| strcpy(data->description, prefix); |
| strcat(data->description, cmd); |
| |
| f->name = data->description; |
| f->data = data; |
| f->open = &archive_compressor_program_open; |
| f->code = ARCHIVE_COMPRESSION_PROGRAM; |
| return (ARCHIVE_OK); |
| } |
| |
| /* |
| * Setup callback. |
| */ |
| static int |
| archive_compressor_program_open(struct archive_write_filter *f) |
| { |
| struct private_data *data = (struct private_data *)f->data; |
| int ret; |
| |
| ret = __archive_write_open_filter(f->next_filter); |
| if (ret != ARCHIVE_OK) |
| return (ret); |
| |
| if (data->child_buf == NULL) { |
| data->child_buf_len = 65536; |
| data->child_buf_avail = 0; |
| data->child_buf = malloc(data->child_buf_len); |
| |
| if (data->child_buf == NULL) { |
| archive_set_error(f->archive, ENOMEM, |
| "Can't allocate compression buffer"); |
| return (ARCHIVE_FATAL); |
| } |
| } |
| |
| if ((data->child = __archive_create_child(data->cmd, |
| &data->child_stdin, &data->child_stdout)) == -1) { |
| archive_set_error(f->archive, EINVAL, |
| "Can't initialise filter"); |
| return (ARCHIVE_FATAL); |
| } |
| |
| f->write = archive_compressor_program_write; |
| f->close = archive_compressor_program_close; |
| f->free = archive_compressor_program_free; |
| return (0); |
| } |
| |
| 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); |
| |
| 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 <= 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; |
| } |
| } |
| |
| /* |
| * Write data to the compressed stream. |
| */ |
| static int |
| archive_compressor_program_write(struct archive_write_filter *f, |
| const void *buff, size_t length) |
| { |
| ssize_t ret; |
| const char *buf; |
| |
| buf = buff; |
| while (length > 0) { |
| ret = child_write(f, buf, length); |
| if (ret == -1 || ret == 0) { |
| archive_set_error(f->archive, EIO, |
| "Can't write to filter"); |
| return (ARCHIVE_FATAL); |
| } |
| length -= ret; |
| buf += ret; |
| } |
| return (ARCHIVE_OK); |
| } |
| |
| |
| /* |
| * 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); |
| } |
| |
| static int |
| archive_compressor_program_free(struct archive_write_filter *f) |
| { |
| struct private_data *data = (struct private_data *)f->data; |
| free(data->cmd); |
| free(data->description); |
| free(data->child_buf); |
| free(data); |
| f->data = NULL; |
| return (ARCHIVE_OK); |
| } |
| |
| #endif /* !defined(HAVE_PIPE) || !defined(HAVE_VFORK) || !defined(HAVE_FCNTL) */ |