contrib/libarchive/libarchive/archive_read_support_filter_program.c

   1 /*-
   2  * Copyright (c) 2007 Joerg Sonnenberger
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
  15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
  18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "archive_platform.h"
  27 __FBSDID("$FreeBSD$");
  28
  29 #ifdef HAVE_SYS_WAIT_H
  30 #  include <sys/wait.h>
  31 #endif
  32 #ifdef HAVE_ERRNO_H
  33 #  include <errno.h>
  34 #endif
  35 #ifdef HAVE_FCNTL_H
  36 #  include <fcntl.h>
  37 #endif
  38 #ifdef HAVE_LIMITS_H
  39 #  include <limits.h>
  40 #endif
  41 #ifdef HAVE_SIGNAL_H
  42 #  include <signal.h>
  43 #endif
  44 #ifdef HAVE_STDLIB_H
  45 #  include <stdlib.h>
  46 #endif
  47 #ifdef HAVE_STRING_H
  48 #  include <string.h>
  49 #endif
  50 #ifdef HAVE_UNISTD_H
  51 #  include <unistd.h>
  52 #endif
  53
  54 #include "archive.h"
  55 #include "archive_private.h"
  56 #include "archive_read_private.h"
  57
  58
  59 #if ARCHIVE_VERSION_NUMBER < 4000000
  60 /* Deprecated; remove in libarchive 4.0 */
  61 int
  62 archive_read_support_compression_program(struct archive *a, const char *cmd)
  63 {
  64         return archive_read_support_filter_program(a, cmd);
  65 }
  66
  67 int
  68 archive_read_support_compression_program_signature(struct archive *a,
  69     const char *cmd, const void *signature, size_t signature_len)
  70 {
  71         return archive_read_support_filter_program_signature(a,
  72             cmd, signature, signature_len);
  73 }
  74 #endif
  75
  76 int
  77 archive_read_support_filter_program(struct archive *a, const char *cmd)
  78 {
  79         return (archive_read_support_filter_program_signature(a, cmd, NULL, 0));
  80 }
  81
  82
  83 /* This capability is only available on POSIX systems. */
  84 #if (!defined(HAVE_PIPE) || !defined(HAVE_FCNTL) || \
  85     !(defined(HAVE_FORK) || defined(HAVE_VFORK))) && (!defined(_WIN32) || defined(__CYGWIN__))
  86
  87 /*
  88  * On non-Posix systems, allow the program to build, but choke if
  89  * this function is actually invoked.
  90  */
  91 int
  92 archive_read_support_filter_program_signature(struct archive *_a,
  93     const char *cmd, const void *signature, size_t signature_len)
  94 {
  95         (void)_a; /* UNUSED */
  96         (void)cmd; /* UNUSED */
  97         (void)signature; /* UNUSED */
  98         (void)signature_len; /* UNUSED */
  99
 100         archive_set_error(_a, -1,
 101             "External compression programs not supported on this platform");
 102         return (ARCHIVE_FATAL);
 103 }
 104
 105 int
 106 __archive_read_program(struct archive_read_filter *self, const char *cmd)
 107 {
 108         (void)self; /* UNUSED */
 109         (void)cmd; /* UNUSED */
 110
 111         archive_set_error(&self->archive->archive, -1,
 112             "External compression programs not supported on this platform");
 113         return (ARCHIVE_FATAL);
 114 }
 115
 116 #else
 117
 118 #include "filter_fork.h"
 119
 120 /*
 121  * The bidder object stores the command and the signature to watch for.
 122  * The 'inhibit' entry here is used to ensure that unchecked filters never
 123  * bid twice in the same pipeline.
 124  */
 125 struct program_bidder {
 126         char *cmd;
 127         void *signature;
 128         size_t signature_len;
 129         int inhibit;
 130 };
 131
 132 static int      program_bidder_bid(struct archive_read_filter_bidder *,
 133                     struct archive_read_filter *upstream);
 134 static int      program_bidder_init(struct archive_read_filter *);
 135 static int      program_bidder_free(struct archive_read_filter_bidder *);
 136
 137 /*
 138  * The actual filter needs to track input and output data.
 139  */
 140 struct program_filter {
 141         char            *description;
 142         pid_t            child;
 143         int              exit_status;
 144         int              waitpid_return;
 145         int              child_stdin, child_stdout;
 146
 147         char            *out_buf;
 148         size_t           out_buf_len;
 149 };
 150
 151 static ssize_t  program_filter_read(struct archive_read_filter *,
 152                     const void **);
 153 static int      program_filter_close(struct archive_read_filter *);
 154
 155 int
 156 archive_read_support_filter_program_signature(struct archive *_a,
 157     const char *cmd, const void *signature, size_t signature_len)
 158 {
 159         struct archive_read *a = (struct archive_read *)_a;
 160         struct archive_read_filter_bidder *bidder;
 161         struct program_bidder *state;
 162
 163         /*
 164          * Get a bidder object from the read core.
 165          */
 166         if (__archive_read_get_bidder(a, &bidder) != ARCHIVE_OK)
 167                 return (ARCHIVE_FATAL);
 168
 169         /*
 170          * Allocate our private state.
 171          */
 172         state = (struct program_bidder *)calloc(sizeof (*state), 1);
 173         if (state == NULL)
 174                 return (ARCHIVE_FATAL);
 175         state->cmd = strdup(cmd);
 176         if (signature != NULL && signature_len > 0) {
 177                 state->signature_len = signature_len;
 178                 state->signature = malloc(signature_len);
 179                 memcpy(state->signature, signature, signature_len);
 180         }
 181
 182         /*
 183          * Fill in the bidder object.
 184          */
 185         bidder->data = state;
 186         bidder->bid = program_bidder_bid;
 187         bidder->init = program_bidder_init;
 188         bidder->options = NULL;
 189         bidder->free = program_bidder_free;
 190         return (ARCHIVE_OK);
 191 }
 192
 193 static int
 194 program_bidder_free(struct archive_read_filter_bidder *self)
 195 {
 196         struct program_bidder *state = (struct program_bidder *)self->data;
 197         free(state->cmd);
 198         free(state->signature);
 199         free(self->data);
 200         return (ARCHIVE_OK);
 201 }
 202
 203 /*
 204  * If we do have a signature, bid only if that matches.
 205  *
 206  * If there's no signature, we bid INT_MAX the first time
 207  * we're called, then never bid again.
 208  */
 209 static int
 210 program_bidder_bid(struct archive_read_filter_bidder *self,
 211     struct archive_read_filter *upstream)
 212 {
 213         struct program_bidder *state = self->data;
 214         const char *p;
 215
 216         /* If we have a signature, use that to match. */
 217         if (state->signature_len > 0) {
 218                 p = __archive_read_filter_ahead(upstream,
 219                     state->signature_len, NULL);
 220                 if (p == NULL)
 221                         return (0);
 222                 /* No match, so don't bid. */
 223                 if (memcmp(p, state->signature, state->signature_len) != 0)
 224                         return (0);
 225                 return ((int)state->signature_len * 8);
 226         }
 227
 228         /* Otherwise, bid once and then never bid again. */
 229         if (state->inhibit)
 230                 return (0);
 231         state->inhibit = 1;
 232         return (INT_MAX);
 233 }
 234
 235 /*
 236  * Shut down the child, return ARCHIVE_OK if it exited normally.
 237  *
 238  * Note that the return value is sticky; if we're called again,
 239  * we won't reap the child again, but we will return the same status
 240  * (including error message if the child came to a bad end).
 241  */
 242 static int
 243 child_stop(struct archive_read_filter *self, struct program_filter *state)
 244 {
 245         /* Close our side of the I/O with the child. */
 246         if (state->child_stdin != -1) {
 247                 close(state->child_stdin);
 248                 state->child_stdin = -1;
 249         }
 250         if (state->child_stdout != -1) {
 251                 close(state->child_stdout);
 252                 state->child_stdout = -1;
 253         }
 254
 255         if (state->child != 0) {
 256                 /* Reap the child. */
 257                 do {
 258                         state->waitpid_return
 259                             = waitpid(state->child, &state->exit_status, 0);
 260                 } while (state->waitpid_return == -1 && errno == EINTR);
 261                 state->child = 0;
 262         }
 263
 264         if (state->waitpid_return < 0) {
 265                 /* waitpid() failed?  This is ugly. */
 266                 archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC,
 267                     "Child process exited badly");
 268                 return (ARCHIVE_WARN);
 269         }
 270
 271 #if !defined(_WIN32) || defined(__CYGWIN__)
 272         if (WIFSIGNALED(state->exit_status)) {
 273 #ifdef SIGPIPE
 274                 /* If the child died because we stopped reading before
 275                  * it was done, that's okay.  Some archive formats
 276                  * have padding at the end that we routinely ignore. */
 277                 /* The alternative to this would be to add a step
 278                  * before close(child_stdout) above to read from the
 279                  * child until the child has no more to write. */
 280                 if (WTERMSIG(state->exit_status) == SIGPIPE)
 281                         return (ARCHIVE_OK);
 282 #endif
 283                 archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC,
 284                     "Child process exited with signal %d",
 285                     WTERMSIG(state->exit_status));
 286                 return (ARCHIVE_WARN);
 287         }
 288 #endif /* !_WIN32 || __CYGWIN__ */
 289
 290         if (WIFEXITED(state->exit_status)) {
 291                 if (WEXITSTATUS(state->exit_status) == 0)
 292                         return (ARCHIVE_OK);
 293
 294                 archive_set_error(&self->archive->archive,
 295                     ARCHIVE_ERRNO_MISC,
 296                     "Child process exited with status %d",
 297                     WEXITSTATUS(state->exit_status));
 298                 return (ARCHIVE_WARN);
 299         }
 300
 301         return (ARCHIVE_WARN);
 302 }
 303
 304 /*
 305  * Use select() to decide whether the child is ready for read or write.
 306  */
 307 static ssize_t
 308 child_read(struct archive_read_filter *self, char *buf, size_t buf_len)
 309 {
 310         struct program_filter *state = self->data;
 311         ssize_t ret, requested, avail;
 312         const char *p;
 313
 314         requested = buf_len > SSIZE_MAX ? SSIZE_MAX : buf_len;
 315
 316         for (;;) {
 317                 do {
 318                         ret = read(state->child_stdout, buf, requested);
 319                 } while (ret == -1 && errno == EINTR);
 320
 321                 if (ret > 0)
 322                         return (ret);
 323                 if (ret == 0 || (ret == -1 && errno == EPIPE))
 324                         /* Child has closed its output; reap the child
 325                          * and return the status. */
 326                         return (child_stop(self, state));
 327                 if (ret == -1 && errno != EAGAIN)
 328                         return (-1);
 329
 330                 if (state->child_stdin == -1) {
 331                         /* Block until child has some I/O ready. */
 332                         __archive_check_child(state->child_stdin,
 333                             state->child_stdout);
 334                         continue;
 335                 }
 336
 337                 /* Get some more data from upstream. */
 338                 p = __archive_read_filter_ahead(self->upstream, 1, &avail);
 339                 if (p == NULL) {
 340                         close(state->child_stdin);
 341                         state->child_stdin = -1;
 342                         fcntl(state->child_stdout, F_SETFL, 0);
 343                         if (avail < 0)
 344                                 return (avail);
 345                         continue;
 346                 }
 347
 348                 do {
 349                         ret = write(state->child_stdin, p, avail);
 350                 } while (ret == -1 && errno == EINTR);
 351
 352                 if (ret > 0) {
 353                         /* Consume whatever we managed to write. */
 354                         __archive_read_filter_consume(self->upstream, ret);
 355                 } else if (ret == -1 && errno == EAGAIN) {
 356                         /* Block until child has some I/O ready. */
 357                         __archive_check_child(state->child_stdin,
 358                             state->child_stdout);
 359                 } else {
 360                         /* Write failed. */
 361                         close(state->child_stdin);
 362                         state->child_stdin = -1;
 363                         fcntl(state->child_stdout, F_SETFL, 0);
 364                         /* If it was a bad error, we're done; otherwise
 365                          * it was EPIPE or EOF, and we can still read
 366                          * from the child. */
 367                         if (ret == -1 && errno != EPIPE)
 368                                 return (-1);
 369                 }
 370         }
 371 }
 372
 373 int
 374 __archive_read_program(struct archive_read_filter *self, const char *cmd)
 375 {
 376         struct program_filter   *state;
 377         static const size_t out_buf_len = 65536;
 378         char *out_buf;
 379         char *description;
 380         const char *prefix = "Program: ";
 381
 382         state = (struct program_filter *)calloc(1, sizeof(*state));
 383         out_buf = (char *)malloc(out_buf_len);
 384         description = (char *)malloc(strlen(prefix) + strlen(cmd) + 1);
 385         if (state == NULL || out_buf == NULL || description == NULL) {
 386                 archive_set_error(&self->archive->archive, ENOMEM,
 387                     "Can't allocate input data");
 388                 free(state);
 389                 free(out_buf);
 390                 free(description);
 391                 return (ARCHIVE_FATAL);
 392         }
 393
 394         self->code = ARCHIVE_COMPRESSION_PROGRAM;
 395         state->description = description;
 396         strcpy(state->description, prefix);
 397         strcat(state->description, cmd);
 398         self->name = state->description;
 399
 400         state->out_buf = out_buf;
 401         state->out_buf_len = out_buf_len;
 402
 403         if ((state->child = __archive_create_child(cmd,
 404                  &state->child_stdin, &state->child_stdout)) == -1) {
 405                 free(state->out_buf);
 406                 free(state);
 407                 archive_set_error(&self->archive->archive, EINVAL,
 408                     "Can't initialize filter; unable to run program \"%s\"", cmd);
 409                 return (ARCHIVE_FATAL);
 410         }
 411
 412         self->data = state;
 413         self->read = program_filter_read;
 414         self->skip = NULL;
 415         self->close = program_filter_close;
 416
 417         /* XXX Check that we can read at least one byte? */
 418         return (ARCHIVE_OK);
 419 }
 420
 421 static int
 422 program_bidder_init(struct archive_read_filter *self)
 423 {
 424         struct program_bidder   *bidder_state;
 425
 426         bidder_state = (struct program_bidder *)self->bidder->data;
 427         return (__archive_read_program(self, bidder_state->cmd));
 428 }
 429
 430 static ssize_t
 431 program_filter_read(struct archive_read_filter *self, const void **buff)
 432 {
 433         struct program_filter *state;
 434         ssize_t bytes;
 435         size_t total;
 436         char *p;
 437
 438         state = (struct program_filter *)self->data;
 439
 440         total = 0;
 441         p = state->out_buf;
 442         while (state->child_stdout != -1 && total < state->out_buf_len) {
 443                 bytes = child_read(self, p, state->out_buf_len - total);
 444                 if (bytes < 0)
 445                         /* No recovery is possible if we can no longer
 446                          * read from the child. */
 447                         return (ARCHIVE_FATAL);
 448                 if (bytes == 0)
 449                         /* We got EOF from the child. */
 450                         break;
 451                 total += bytes;
 452                 p += bytes;
 453         }
 454
 455         *buff = state->out_buf;
 456         return (total);
 457 }
 458
 459 static int
 460 program_filter_close(struct archive_read_filter *self)
 461 {
 462         struct program_filter   *state;
 463         int e;
 464
 465         state = (struct program_filter *)self->data;
 466         e = child_stop(self, state);
 467
 468         /* Release our private data. */
 469         free(state->out_buf);
 470         free(state->description);
 471         free(state);
 472
 473         return (e);
 474 }
 475
 476 #endif /* !defined(HAVE_PIPE) || !defined(HAVE_VFORK) || !defined(HAVE_FCNTL) */