contrib/libarchive/libarchive/archive_read_support_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$");
  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_LIMITS_H
  40 #  include <limits.h>
  41 #endif
  42 #ifdef HAVE_SIGNAL_H
  43 #  include <signal.h>
  44 #endif
  45 #ifdef HAVE_STDLIB_H
  46 #  include <stdlib.h>
  47 #endif
  48 #ifdef HAVE_STRING_H
  49 #  include <string.h>
  50 #endif
  51 #ifdef HAVE_UNISTD_H
  52 #  include <unistd.h>
  53 #endif
  54
  55 #include "archive.h"
  56 #include "archive_private.h"
  57 #include "archive_string.h"
  58 #include "archive_read_private.h"
  59 #include "filter_fork.h"
  60
  61
  62 #if ARCHIVE_VERSION_NUMBER < 4000000
  63 /* Deprecated; remove in libarchive 4.0 */
  64 int
  65 archive_read_support_compression_program(struct archive *a, const char *cmd)
  66 {
  67         return archive_read_support_filter_program(a, cmd);
  68 }
  69
  70 int
  71 archive_read_support_compression_program_signature(struct archive *a,
  72     const char *cmd, const void *signature, size_t signature_len)
  73 {
  74         return archive_read_support_filter_program_signature(a,
  75             cmd, signature, signature_len);
  76 }
  77 #endif
  78
  79 int
  80 archive_read_support_filter_program(struct archive *a, const char *cmd)
  81 {
  82         return (archive_read_support_filter_program_signature(a, cmd, NULL, 0));
  83 }
  84
  85 /*
  86  * The bidder object stores the command and the signature to watch for.
  87  * The 'inhibit' entry here is used to ensure that unchecked filters never
  88  * bid twice in the same pipeline.
  89  */
  90 struct program_bidder {
  91         char *description;
  92         char *cmd;
  93         void *signature;
  94         size_t signature_len;
  95         int inhibit;
  96 };
  97
  98 static int      program_bidder_bid(struct archive_read_filter_bidder *,
  99                     struct archive_read_filter *upstream);
 100 static int      program_bidder_init(struct archive_read_filter *);
 101 static void     program_bidder_free(struct archive_read_filter_bidder *);
 102
 103 /*
 104  * The actual filter needs to track input and output data.
 105  */
 106 struct program_filter {
 107         struct archive_string description;
 108 #if defined(_WIN32) && !defined(__CYGWIN__)
 109         HANDLE           child;
 110 #else
 111         pid_t            child;
 112 #endif
 113         int              exit_status;
 114         int              waitpid_return;
 115         int              child_stdin, child_stdout;
 116
 117         char            *out_buf;
 118         size_t           out_buf_len;
 119 };
 120
 121 static ssize_t  program_filter_read(struct archive_read_filter *,
 122                     const void **);
 123 static int      program_filter_close(struct archive_read_filter *);
 124 static void     free_state(struct program_bidder *);
 125
 126 static const struct archive_read_filter_bidder_vtable
 127 program_bidder_vtable = {
 128         .bid = program_bidder_bid,
 129         .init = program_bidder_init,
 130         .free = program_bidder_free,
 131 };
 132
 133 int
 134 archive_read_support_filter_program_signature(struct archive *_a,
 135     const char *cmd, const void *signature, size_t signature_len)
 136 {
 137         struct archive_read *a = (struct archive_read *)_a;
 138         struct program_bidder *state;
 139
 140         /*
 141          * Allocate our private state.
 142          */
 143         state = (struct program_bidder *)calloc(1, sizeof (*state));
 144         if (state == NULL)
 145                 goto memerr;
 146         state->cmd = strdup(cmd);
 147         if (state->cmd == NULL)
 148                 goto memerr;
 149
 150         if (signature != NULL && signature_len > 0) {
 151                 state->signature_len = signature_len;
 152                 state->signature = malloc(signature_len);
 153                 memcpy(state->signature, signature, signature_len);
 154         }
 155
 156         if (__archive_read_register_bidder(a, state, NULL,
 157                                 &program_bidder_vtable) != ARCHIVE_OK) {
 158                 free_state(state);
 159                 return (ARCHIVE_FATAL);
 160         }
 161         return (ARCHIVE_OK);
 162
 163 memerr:
 164         free_state(state);
 165         archive_set_error(_a, ENOMEM, "Can't allocate memory");
 166         return (ARCHIVE_FATAL);
 167 }
 168
 169 static void
 170 program_bidder_free(struct archive_read_filter_bidder *self)
 171 {
 172         struct program_bidder *state = (struct program_bidder *)self->data;
 173
 174         free_state(state);
 175 }
 176
 177 static void
 178 free_state(struct program_bidder *state)
 179 {
 180
 181         if (state) {
 182                 free(state->cmd);
 183                 free(state->signature);
 184                 free(state);
 185         }
 186 }
 187
 188 /*
 189  * If we do have a signature, bid only if that matches.
 190  *
 191  * If there's no signature, we bid INT_MAX the first time
 192  * we're called, then never bid again.
 193  */
 194 static int
 195 program_bidder_bid(struct archive_read_filter_bidder *self,
 196     struct archive_read_filter *upstream)
 197 {
 198         struct program_bidder *state = self->data;
 199         const char *p;
 200
 201         /* If we have a signature, use that to match. */
 202         if (state->signature_len > 0) {
 203                 p = __archive_read_filter_ahead(upstream,
 204                     state->signature_len, NULL);
 205                 if (p == NULL)
 206                         return (0);
 207                 /* No match, so don't bid. */
 208                 if (memcmp(p, state->signature, state->signature_len) != 0)
 209                         return (0);
 210                 return ((int)state->signature_len * 8);
 211         }
 212
 213         /* Otherwise, bid once and then never bid again. */
 214         if (state->inhibit)
 215                 return (0);
 216         state->inhibit = 1;
 217         return (INT_MAX);
 218 }
 219
 220 /*
 221  * Shut down the child, return ARCHIVE_OK if it exited normally.
 222  *
 223  * Note that the return value is sticky; if we're called again,
 224  * we won't reap the child again, but we will return the same status
 225  * (including error message if the child came to a bad end).
 226  */
 227 static int
 228 child_stop(struct archive_read_filter *self, struct program_filter *state)
 229 {
 230         /* Close our side of the I/O with the child. */
 231         if (state->child_stdin != -1) {
 232                 close(state->child_stdin);
 233                 state->child_stdin = -1;
 234         }
 235         if (state->child_stdout != -1) {
 236                 close(state->child_stdout);
 237                 state->child_stdout = -1;
 238         }
 239
 240         if (state->child != 0) {
 241                 /* Reap the child. */
 242                 do {
 243                         state->waitpid_return
 244                             = waitpid(state->child, &state->exit_status, 0);
 245                 } while (state->waitpid_return == -1 && errno == EINTR);
 246 #if defined(_WIN32) && !defined(__CYGWIN__)
 247                 CloseHandle(state->child);
 248 #endif
 249                 state->child = 0;
 250         }
 251
 252         if (state->waitpid_return < 0) {
 253                 /* waitpid() failed?  This is ugly. */
 254                 archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC,
 255                     "Child process exited badly");
 256                 return (ARCHIVE_WARN);
 257         }
 258
 259 #if !defined(_WIN32) || defined(__CYGWIN__)
 260         if (WIFSIGNALED(state->exit_status)) {
 261 #ifdef SIGPIPE
 262                 /* If the child died because we stopped reading before
 263                  * it was done, that's okay.  Some archive formats
 264                  * have padding at the end that we routinely ignore. */
 265                 /* The alternative to this would be to add a step
 266                  * before close(child_stdout) above to read from the
 267                  * child until the child has no more to write. */
 268                 if (WTERMSIG(state->exit_status) == SIGPIPE)
 269                         return (ARCHIVE_OK);
 270 #endif
 271                 archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC,
 272                     "Child process exited with signal %d",
 273                     WTERMSIG(state->exit_status));
 274                 return (ARCHIVE_WARN);
 275         }
 276 #endif /* !_WIN32 || __CYGWIN__ */
 277
 278         if (WIFEXITED(state->exit_status)) {
 279                 if (WEXITSTATUS(state->exit_status) == 0)
 280                         return (ARCHIVE_OK);
 281
 282                 archive_set_error(&self->archive->archive,
 283                     ARCHIVE_ERRNO_MISC,
 284                     "Child process exited with status %d",
 285                     WEXITSTATUS(state->exit_status));
 286                 return (ARCHIVE_WARN);
 287         }
 288
 289         return (ARCHIVE_WARN);
 290 }
 291
 292 /*
 293  * Use select() to decide whether the child is ready for read or write.
 294  */
 295 static ssize_t
 296 child_read(struct archive_read_filter *self, char *buf, size_t buf_len)
 297 {
 298         struct program_filter *state = self->data;
 299         ssize_t ret, requested, avail;
 300         const char *p;
 301 #if defined(_WIN32) && !defined(__CYGWIN__)
 302         HANDLE handle = (HANDLE)_get_osfhandle(state->child_stdout);
 303 #endif
 304
 305         requested = buf_len > SSIZE_MAX ? SSIZE_MAX : buf_len;
 306
 307         for (;;) {
 308                 do {
 309 #if defined(_WIN32) && !defined(__CYGWIN__)
 310                         /* Avoid infinity wait.
 311                          * Note: If there is no data in the pipe, ReadFile()
 312                          * called in read() never returns and so we won't
 313                          * write remaining encoded data to the pipe.
 314                          * Note: This way may cause performance problem.
 315                          * we are looking forward to great code to resolve
 316                          * this.  */
 317                         DWORD pipe_avail = -1;
 318                         int cnt = 2;
 319
 320                         while (PeekNamedPipe(handle, NULL, 0, NULL,
 321                             &pipe_avail, NULL) != 0 && pipe_avail == 0 &&
 322                             cnt--)
 323                                 Sleep(5);
 324                         if (pipe_avail == 0) {
 325                                 ret = -1;
 326                                 errno = EAGAIN;
 327                                 break;
 328                         }
 329 #endif
 330                         ret = read(state->child_stdout, buf, requested);
 331                 } while (ret == -1 && errno == EINTR);
 332
 333                 if (ret > 0)
 334                         return (ret);
 335                 if (ret == 0 || (ret == -1 && errno == EPIPE))
 336                         /* Child has closed its output; reap the child
 337                          * and return the status. */
 338                         return (child_stop(self, state));
 339                 if (ret == -1 && errno != EAGAIN)
 340                         return (-1);
 341
 342                 if (state->child_stdin == -1) {
 343                         /* Block until child has some I/O ready. */
 344                         __archive_check_child(state->child_stdin,
 345                             state->child_stdout);
 346                         continue;
 347                 }
 348
 349                 /* Get some more data from upstream. */
 350                 p = __archive_read_filter_ahead(self->upstream, 1, &avail);
 351                 if (p == NULL) {
 352                         close(state->child_stdin);
 353                         state->child_stdin = -1;
 354                         fcntl(state->child_stdout, F_SETFL, 0);
 355                         if (avail < 0)
 356                                 return (avail);
 357                         continue;
 358                 }
 359
 360                 do {
 361                         ret = write(state->child_stdin, p, avail);
 362                 } while (ret == -1 && errno == EINTR);
 363
 364                 if (ret > 0) {
 365                         /* Consume whatever we managed to write. */
 366                         __archive_read_filter_consume(self->upstream, ret);
 367                 } else if (ret == -1 && errno == EAGAIN) {
 368                         /* Block until child has some I/O ready. */
 369                         __archive_check_child(state->child_stdin,
 370                             state->child_stdout);
 371                 } else {
 372                         /* Write failed. */
 373                         close(state->child_stdin);
 374                         state->child_stdin = -1;
 375                         fcntl(state->child_stdout, F_SETFL, 0);
 376                         /* If it was a bad error, we're done; otherwise
 377                          * it was EPIPE or EOF, and we can still read
 378                          * from the child. */
 379                         if (ret == -1 && errno != EPIPE)
 380                                 return (-1);
 381                 }
 382         }
 383 }
 384
 385 static const struct archive_read_filter_vtable
 386 program_reader_vtable = {
 387         .read = program_filter_read,
 388         .close = program_filter_close,
 389 };
 390
 391 int
 392 __archive_read_program(struct archive_read_filter *self, const char *cmd)
 393 {
 394         struct program_filter   *state;
 395         static const size_t out_buf_len = 65536;
 396         char *out_buf;
 397         const char *prefix = "Program: ";
 398         int ret;
 399         size_t l;
 400
 401         l = strlen(prefix) + strlen(cmd) + 1;
 402         state = (struct program_filter *)calloc(1, sizeof(*state));
 403         out_buf = (char *)malloc(out_buf_len);
 404         if (state == NULL || out_buf == NULL ||
 405             archive_string_ensure(&state->description, l) == NULL) {
 406                 archive_set_error(&self->archive->archive, ENOMEM,
 407                     "Can't allocate input data");
 408                 if (state != NULL) {
 409                         archive_string_free(&state->description);
 410                         free(state);
 411                 }
 412                 free(out_buf);
 413                 return (ARCHIVE_FATAL);
 414         }
 415         archive_strcpy(&state->description, prefix);
 416         archive_strcat(&state->description, cmd);
 417
 418         self->code = ARCHIVE_FILTER_PROGRAM;
 419         self->name = state->description.s;
 420
 421         state->out_buf = out_buf;
 422         state->out_buf_len = out_buf_len;
 423
 424         ret = __archive_create_child(cmd, &state->child_stdin,
 425             &state->child_stdout, &state->child);
 426         if (ret != ARCHIVE_OK) {
 427                 free(state->out_buf);
 428                 archive_string_free(&state->description);
 429                 free(state);
 430                 archive_set_error(&self->archive->archive, EINVAL,
 431                     "Can't initialize filter; unable to run program \"%s\"",
 432                     cmd);
 433                 return (ARCHIVE_FATAL);
 434         }
 435
 436         self->data = state;
 437         self->vtable = &program_reader_vtable;
 438
 439         /* XXX Check that we can read at least one byte? */
 440         return (ARCHIVE_OK);
 441 }
 442
 443 static int
 444 program_bidder_init(struct archive_read_filter *self)
 445 {
 446         struct program_bidder   *bidder_state;
 447
 448         bidder_state = (struct program_bidder *)self->bidder->data;
 449         return (__archive_read_program(self, bidder_state->cmd));
 450 }
 451
 452 static ssize_t
 453 program_filter_read(struct archive_read_filter *self, const void **buff)
 454 {
 455         struct program_filter *state;
 456         ssize_t bytes;
 457         size_t total;
 458         char *p;
 459
 460         state = (struct program_filter *)self->data;
 461
 462         total = 0;
 463         p = state->out_buf;
 464         while (state->child_stdout != -1 && total < state->out_buf_len) {
 465                 bytes = child_read(self, p, state->out_buf_len - total);
 466                 if (bytes < 0)
 467                         /* No recovery is possible if we can no longer
 468                          * read from the child. */
 469                         return (ARCHIVE_FATAL);
 470                 if (bytes == 0)
 471                         /* We got EOF from the child. */
 472                         break;
 473                 total += bytes;
 474                 p += bytes;
 475         }
 476
 477         *buff = state->out_buf;
 478         return (total);
 479 }
 480
 481 static int
 482 program_filter_close(struct archive_read_filter *self)
 483 {
 484         struct program_filter   *state;
 485         int e;
 486
 487         state = (struct program_filter *)self->data;
 488         e = child_stop(self, state);
 489
 490         /* Release our private data. */
 491         free(state->out_buf);
 492         archive_string_free(&state->description);
 493         free(state);
 494
 495         return (e);
 496 }