contrib/libarchive/libarchive/archive_write_add_filter_program.c

   1 /*-
   2  * Copyright (c) 2007 Joerg Sonnenberger
   3  * Copyright (c) 2012 Michihiro NAKAJIMA
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include "archive_platform.h"
  28 __FBSDID("$FreeBSD: head/lib/libarchive/archive_write_set_compression_program.c 201104 2009-12-28 03:14:30Z kientzle $");
  29
  30 #ifdef HAVE_SYS_WAIT_H
  31 #  include <sys/wait.h>
  32 #endif
  33 #ifdef HAVE_ERRNO_H
  34 #  include <errno.h>
  35 #endif
  36 #ifdef HAVE_FCNTL_H
  37 #  include <fcntl.h>
  38 #endif
  39 #ifdef HAVE_STDLIB_H
  40 #  include <stdlib.h>
  41 #endif
  42 #ifdef HAVE_STRING_H
  43 #  include <string.h>
  44 #endif
  45
  46 #include "archive.h"
  47 #include "archive_private.h"
  48 #include "archive_string.h"
  49 #include "archive_write_private.h"
  50 #include "filter_fork.h"
  51
  52 #if ARCHIVE_VERSION_NUMBER < 4000000
  53 int
  54 archive_write_set_compression_program(struct archive *a, const char *cmd)
  55 {
  56         __archive_write_filters_free(a);
  57         return (archive_write_add_filter_program(a, cmd));
  58 }
  59 #endif
  60
  61 struct archive_write_program_data {
  62 #if defined(_WIN32) && !defined(__CYGWIN__)
  63         HANDLE           child;
  64 #else
  65         pid_t            child;
  66 #endif
  67         int              child_stdin, child_stdout;
  68
  69         char            *child_buf;
  70         size_t           child_buf_len, child_buf_avail;
  71 };
  72
  73 struct private_data {
  74         struct archive_write_program_data *pdata;
  75         struct archive_string description;
  76         char            *cmd;
  77 };
  78
  79 static int archive_compressor_program_open(struct archive_write_filter *);
  80 static int archive_compressor_program_write(struct archive_write_filter *,
  81                     const void *, size_t);
  82 static int archive_compressor_program_close(struct archive_write_filter *);
  83 static int archive_compressor_program_free(struct archive_write_filter *);
  84
  85 /*
  86  * Add a filter to this write handle that passes all data through an
  87  * external program.
  88  */
  89 int
  90 archive_write_add_filter_program(struct archive *_a, const char *cmd)
  91 {
  92         struct archive_write_filter *f = __archive_write_allocate_filter(_a);
  93         struct private_data *data;
  94         static const char *prefix = "Program: ";
  95
  96         archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
  97             ARCHIVE_STATE_NEW, "archive_write_add_filter_program");
  98
  99         f->data = calloc(1, sizeof(*data));
 100         if (f->data == NULL)
 101                 goto memerr;
 102         data = (struct private_data *)f->data;
 103
 104         data->cmd = strdup(cmd);
 105         if (data->cmd == NULL)
 106                 goto memerr;
 107
 108         data->pdata = __archive_write_program_allocate();
 109         if (data->pdata == NULL)
 110                 goto memerr;
 111
 112         /* Make up a description string. */
 113         if (archive_string_ensure(&data->description,
 114             strlen(prefix) + strlen(cmd) + 1) == NULL)
 115                 goto memerr;
 116         archive_strcpy(&data->description, prefix);
 117         archive_strcat(&data->description, cmd);
 118
 119         f->name = data->description.s;
 120         f->code = ARCHIVE_FILTER_PROGRAM;
 121         f->open = archive_compressor_program_open;
 122         f->write = archive_compressor_program_write;
 123         f->close = archive_compressor_program_close;
 124         f->free = archive_compressor_program_free;
 125         return (ARCHIVE_OK);
 126 memerr:
 127         archive_compressor_program_free(f);
 128         archive_set_error(_a, ENOMEM,
 129             "Can't allocate memory for filter program");
 130         return (ARCHIVE_FATAL);
 131 }
 132
 133 static int
 134 archive_compressor_program_open(struct archive_write_filter *f)
 135 {
 136         struct private_data *data = (struct private_data *)f->data;
 137
 138         return __archive_write_program_open(f, data->pdata, data->cmd);
 139 }
 140
 141 static int
 142 archive_compressor_program_write(struct archive_write_filter *f,
 143     const void *buff, size_t length)
 144 {
 145         struct private_data *data = (struct private_data *)f->data;
 146
 147         return __archive_write_program_write(f, data->pdata, buff, length);
 148 }
 149
 150 static int
 151 archive_compressor_program_close(struct archive_write_filter *f)
 152 {
 153         struct private_data *data = (struct private_data *)f->data;
 154
 155         return __archive_write_program_close(f, data->pdata);
 156 }
 157
 158 static int
 159 archive_compressor_program_free(struct archive_write_filter *f)
 160 {
 161         struct private_data *data = (struct private_data *)f->data;
 162
 163         if (data) {
 164                 free(data->cmd);
 165                 archive_string_free(&data->description);
 166                 __archive_write_program_free(data->pdata);
 167                 free(data);
 168                 f->data = NULL;
 169         }
 170         return (ARCHIVE_OK);
 171 }
 172
 173 /*
 174  * Allocate resources for executing an external program.
 175  */
 176 struct archive_write_program_data *
 177 __archive_write_program_allocate(void)
 178 {
 179         struct archive_write_program_data *data;
 180
 181         data = calloc(1, sizeof(struct archive_write_program_data));
 182         if (data == NULL)
 183                 return (data);
 184         data->child_stdin = -1;
 185         data->child_stdout = -1;
 186         return (data);
 187 }
 188
 189 /*
 190  * Release the resources.
 191  */
 192 int
 193 __archive_write_program_free(struct archive_write_program_data *data)
 194 {
 195
 196         if (data) {
 197 #if defined(_WIN32) && !defined(__CYGWIN__)
 198                 if (data->child)
 199                         CloseHandle(data->child);
 200 #endif
 201                 free(data->child_buf);
 202                 free(data);
 203         }
 204         return (ARCHIVE_OK);
 205 }
 206
 207 int
 208 __archive_write_program_open(struct archive_write_filter *f,
 209     struct archive_write_program_data *data, const char *cmd)
 210 {
 211         pid_t child;
 212         int ret;
 213
 214         ret = __archive_write_open_filter(f->next_filter);
 215         if (ret != ARCHIVE_OK)
 216                 return (ret);
 217
 218         if (data->child_buf == NULL) {
 219                 data->child_buf_len = 65536;
 220                 data->child_buf_avail = 0;
 221                 data->child_buf = malloc(data->child_buf_len);
 222
 223                 if (data->child_buf == NULL) {
 224                         archive_set_error(f->archive, ENOMEM,
 225                             "Can't allocate compression buffer");
 226                         return (ARCHIVE_FATAL);
 227                 }
 228         }
 229
 230         child = __archive_create_child(cmd, &data->child_stdin,
 231                     &data->child_stdout);
 232         if (child == -1) {
 233                 archive_set_error(f->archive, EINVAL,
 234                     "Can't initialise filter");
 235                 return (ARCHIVE_FATAL);
 236         }
 237 #if defined(_WIN32) && !defined(__CYGWIN__)
 238         data->child = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, child);
 239         if (data->child == NULL) {
 240                 close(data->child_stdin);
 241                 data->child_stdin = -1;
 242                 close(data->child_stdout);
 243                 data->child_stdout = -1;
 244                 archive_set_error(f->archive, EINVAL,
 245                     "Can't initialise filter");
 246                 return (ARCHIVE_FATAL);
 247         }
 248 #else
 249         data->child = child;
 250 #endif
 251         return (ARCHIVE_OK);
 252 }
 253
 254 static ssize_t
 255 child_write(struct archive_write_filter *f,
 256     struct archive_write_program_data *data, const char *buf, size_t buf_len)
 257 {
 258         ssize_t ret;
 259
 260         if (data->child_stdin == -1)
 261                 return (-1);
 262
 263         if (buf_len == 0)
 264                 return (-1);
 265
 266         for (;;) {
 267                 do {
 268                         ret = write(data->child_stdin, buf, buf_len);
 269                 } while (ret == -1 && errno == EINTR);
 270
 271                 if (ret > 0)
 272                         return (ret);
 273                 if (ret == 0) {
 274                         close(data->child_stdin);
 275                         data->child_stdin = -1;
 276                         fcntl(data->child_stdout, F_SETFL, 0);
 277                         return (0);
 278                 }
 279                 if (ret == -1 && errno != EAGAIN)
 280                         return (-1);
 281
 282                 if (data->child_stdout == -1) {
 283                         fcntl(data->child_stdin, F_SETFL, 0);
 284                         __archive_check_child(data->child_stdin,
 285                                 data->child_stdout);
 286                         continue;
 287                 }
 288
 289                 do {
 290                         ret = read(data->child_stdout,
 291                             data->child_buf + data->child_buf_avail,
 292                             data->child_buf_len - data->child_buf_avail);
 293                 } while (ret == -1 && errno == EINTR);
 294
 295                 if (ret == 0 || (ret == -1 && errno == EPIPE)) {
 296                         close(data->child_stdout);
 297                         data->child_stdout = -1;
 298                         fcntl(data->child_stdin, F_SETFL, 0);
 299                         continue;
 300                 }
 301                 if (ret == -1 && errno == EAGAIN) {
 302                         __archive_check_child(data->child_stdin,
 303                                 data->child_stdout);
 304                         continue;
 305                 }
 306                 if (ret == -1)
 307                         return (-1);
 308
 309                 data->child_buf_avail += ret;
 310
 311                 ret = __archive_write_filter(f->next_filter,
 312                     data->child_buf, data->child_buf_avail);
 313                 if (ret != ARCHIVE_OK)
 314                         return (-1);
 315                 data->child_buf_avail = 0;
 316         }
 317 }
 318
 319 /*
 320  * Write data to the filter stream.
 321  */
 322 int
 323 __archive_write_program_write(struct archive_write_filter *f,
 324     struct archive_write_program_data *data, const void *buff, size_t length)
 325 {
 326         ssize_t ret;
 327         const char *buf;
 328
 329         if (data->child == 0)
 330                 return (ARCHIVE_OK);
 331
 332         buf = buff;
 333         while (length > 0) {
 334                 ret = child_write(f, data, buf, length);
 335                 if (ret == -1 || ret == 0) {
 336                         archive_set_error(f->archive, EIO,
 337                             "Can't write to filter");
 338                         return (ARCHIVE_FATAL);
 339                 }
 340                 length -= ret;
 341                 buf += ret;
 342         }
 343         return (ARCHIVE_OK);
 344 }
 345
 346 /*
 347  * Finish the filtering...
 348  */
 349 int
 350 __archive_write_program_close(struct archive_write_filter *f,
 351     struct archive_write_program_data *data)
 352 {
 353         int ret, r1, status;
 354         ssize_t bytes_read;
 355
 356         if (data->child == 0)
 357                 return __archive_write_close_filter(f->next_filter);
 358
 359         ret = 0;
 360         close(data->child_stdin);
 361         data->child_stdin = -1;
 362         fcntl(data->child_stdout, F_SETFL, 0);
 363
 364         for (;;) {
 365                 do {
 366                         bytes_read = read(data->child_stdout,
 367                             data->child_buf + data->child_buf_avail,
 368                             data->child_buf_len - data->child_buf_avail);
 369                 } while (bytes_read == -1 && errno == EINTR);
 370
 371                 if (bytes_read == 0 || (bytes_read == -1 && errno == EPIPE))
 372                         break;
 373
 374                 if (bytes_read == -1) {
 375                         archive_set_error(f->archive, errno,
 376                             "Read from filter failed unexpectedly.");
 377                         ret = ARCHIVE_FATAL;
 378                         goto cleanup;
 379                 }
 380                 data->child_buf_avail += bytes_read;
 381
 382                 ret = __archive_write_filter(f->next_filter,
 383                     data->child_buf, data->child_buf_avail);
 384                 if (ret != ARCHIVE_OK) {
 385                         ret = ARCHIVE_FATAL;
 386                         goto cleanup;
 387                 }
 388                 data->child_buf_avail = 0;
 389         }
 390
 391 cleanup:
 392         /* Shut down the child. */
 393         if (data->child_stdin != -1)
 394                 close(data->child_stdin);
 395         if (data->child_stdout != -1)
 396                 close(data->child_stdout);
 397         while (waitpid(data->child, &status, 0) == -1 && errno == EINTR)
 398                 continue;
 399 #if defined(_WIN32) && !defined(__CYGWIN__)
 400         CloseHandle(data->child);
 401 #endif
 402         data->child = 0;
 403
 404         if (status != 0) {
 405                 archive_set_error(f->archive, EIO,
 406                     "Filter exited with failure.");
 407                 ret = ARCHIVE_FATAL;
 408         }
 409         r1 = __archive_write_close_filter(f->next_filter);
 410         return (r1 < ret ? r1 : ret);
 411 }
 412