archival/libarchive/open_transformer.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
   4  */
   5
   6 #include "libbb.h"
   7 #include "bb_archive.h"
   8
   9 void FAST_FUNC init_transformer_state(transformer_state_t *xstate)
  10 {
  11         memset(xstate, 0, sizeof(*xstate));
  12 }
  13
  14 int FAST_FUNC check_signature16(transformer_state_t *xstate, unsigned magic16)
  15 {
  16         if (xstate->check_signature) {
  17                 uint16_t magic2;
  18                 if (full_read(xstate->src_fd, &magic2, 2) != 2 || magic2 != magic16) {
  19                         bb_error_msg("invalid magic");
  20 #if 0 /* possible future extension */
  21                         if (xstate->check_signature > 1)
  22                                 xfunc_die();
  23 #endif
  24                         return -1;
  25                 }
  26         }
  27         return 0;
  28 }
  29
  30 ssize_t FAST_FUNC transformer_write(transformer_state_t *xstate, const void *buf, size_t bufsize)
  31 {
  32         ssize_t nwrote;
  33
  34         if (xstate->mem_output_size_max != 0) {
  35                 size_t pos = xstate->mem_output_size;
  36                 size_t size;
  37
  38                 size = (xstate->mem_output_size += bufsize);
  39                 if (size > xstate->mem_output_size_max) {
  40                         free(xstate->mem_output_buf);
  41                         xstate->mem_output_buf = NULL;
  42                         bb_perror_msg("buffer %u too small", (unsigned)xstate->mem_output_size_max);
  43                         nwrote = -1;
  44                         goto ret;
  45                 }
  46                 xstate->mem_output_buf = xrealloc(xstate->mem_output_buf, size + 1);
  47                 memcpy(xstate->mem_output_buf + pos, buf, bufsize);
  48                 xstate->mem_output_buf[size] = '\0';
  49                 nwrote = bufsize;
  50         } else {
  51                 nwrote = full_write(xstate->dst_fd, buf, bufsize);
  52                 if (nwrote != (ssize_t)bufsize) {
  53                         bb_perror_msg("write");
  54                         nwrote = -1;
  55                         goto ret;
  56                 }
  57         }
  58  ret:
  59         return nwrote;
  60 }
  61
  62 ssize_t FAST_FUNC xtransformer_write(transformer_state_t *xstate, const void *buf, size_t bufsize)
  63 {
  64         ssize_t nwrote = transformer_write(xstate, buf, bufsize);
  65         if (nwrote != (ssize_t)bufsize) {
  66                 xfunc_die();
  67         }
  68         return nwrote;
  69 }
  70
  71 void check_errors_in_children(int signo)
  72 {
  73         int status;
  74
  75         if (!signo) {
  76                 /* block waiting for any child */
  77                 if (wait(&status) < 0)
  78 //FIXME: check EINTR?
  79                         return; /* probably there are no children */
  80                 goto check_status;
  81         }
  82
  83         /* Wait for any child without blocking */
  84         for (;;) {
  85                 if (wait_any_nohang(&status) < 0)
  86 //FIXME: check EINTR?
  87                         /* wait failed?! I'm confused... */
  88                         return;
  89  check_status:
  90                 /*if (WIFEXITED(status) && WEXITSTATUS(status) == 0)*/
  91                 /* On Linux, the above can be checked simply as: */
  92                 if (status == 0)
  93                         /* this child exited with 0 */
  94                         continue;
  95                 /* Cannot happen:
  96                 if (!WIFSIGNALED(status) && !WIFEXITED(status)) ???;
  97                  */
  98                 bb_got_signal = 1;
  99         }
 100 }
 101
 102 /* transformer(), more than meets the eye */
 103 #if BB_MMU
 104 void FAST_FUNC fork_transformer(int fd,
 105         int check_signature,
 106         IF_DESKTOP(long long) int FAST_FUNC (*transformer)(transformer_state_t *xstate)
 107 )
 108 #else
 109 void FAST_FUNC fork_transformer(int fd, const char *transform_prog)
 110 #endif
 111 {
 112         struct fd_pair fd_pipe;
 113         int pid;
 114
 115         xpiped_pair(fd_pipe);
 116         pid = BB_MMU ? xfork() : xvfork();
 117         if (pid == 0) {
 118                 /* Child */
 119                 close(fd_pipe.rd); /* we don't want to read from the parent */
 120                 // FIXME: error check?
 121 #if BB_MMU
 122                 {
 123                         IF_DESKTOP(long long) int r;
 124                         transformer_state_t xstate;
 125                         init_transformer_state(&xstate);
 126                         xstate.check_signature = check_signature;
 127                         xstate.src_fd = fd;
 128                         xstate.dst_fd = fd_pipe.wr;
 129                         r = transformer(&xstate);
 130                         if (ENABLE_FEATURE_CLEAN_UP) {
 131                                 close(fd_pipe.wr); /* send EOF */
 132                                 close(fd);
 133                         }
 134                         /* must be _exit! bug was actually seen here */
 135                         _exit(/*error if:*/ r < 0);
 136                 }
 137 #else
 138                 {
 139                         char *argv[4];
 140                         xmove_fd(fd, 0);
 141                         xmove_fd(fd_pipe.wr, 1);
 142                         argv[0] = (char*)transform_prog;
 143                         argv[1] = (char*)"-cf";
 144                         argv[2] = (char*)"-";
 145                         argv[3] = NULL;
 146                         BB_EXECVP(transform_prog, argv);
 147                         bb_perror_msg_and_die("can't execute '%s'", transform_prog);
 148                 }
 149 #endif
 150                 /* notreached */
 151         }
 152
 153         /* parent process */
 154         close(fd_pipe.wr); /* don't want to write to the child */
 155         xmove_fd(fd_pipe.rd, fd);
 156 }
 157
 158
 159 #if SEAMLESS_COMPRESSION
 160
 161 /* Used by e.g. rpm which gives us a fd without filename,
 162  * thus we can't guess the format from filename's extension.
 163  */
 164 static transformer_state_t *setup_transformer_on_fd(int fd, int fail_if_not_compressed)
 165 {
 166         union {
 167                 uint8_t b[4];
 168                 uint16_t b16[2];
 169                 uint32_t b32[1];
 170         } magic;
 171         int offset;
 172         transformer_state_t *xstate;
 173
 174         offset = -2;
 175         xstate = xzalloc(sizeof(*xstate));
 176         xstate->src_fd = fd;
 177
 178         /* .gz and .bz2 both have 2-byte signature, and their
 179          * unpack_XXX_stream wants this header skipped. */
 180         xread(fd, magic.b16, sizeof(magic.b16[0]));
 181         if (ENABLE_FEATURE_SEAMLESS_GZ
 182          && magic.b16[0] == GZIP_MAGIC
 183         ) {
 184                 xstate->xformer = unpack_gz_stream;
 185                 USE_FOR_NOMMU(xstate->xformer_prog = "gunzip";)
 186                 goto found_magic;
 187         }
 188         if (ENABLE_FEATURE_SEAMLESS_BZ2
 189          && magic.b16[0] == BZIP2_MAGIC
 190         ) {
 191                 xstate->xformer = unpack_bz2_stream;
 192                 USE_FOR_NOMMU(xstate->xformer_prog = "bunzip2";)
 193                 goto found_magic;
 194         }
 195         if (ENABLE_FEATURE_SEAMLESS_XZ
 196          && magic.b16[0] == XZ_MAGIC1
 197         ) {
 198                 offset = -6;
 199                 xread(fd, magic.b32, sizeof(magic.b32[0]));
 200                 if (magic.b32[0] == XZ_MAGIC2) {
 201                         xstate->xformer = unpack_xz_stream;
 202                         USE_FOR_NOMMU(xstate->xformer_prog = "unxz";)
 203                         goto found_magic;
 204                 }
 205         }
 206
 207         /* No known magic seen */
 208         if (fail_if_not_compressed)
 209                 bb_error_msg_and_die("no gzip"
 210                         IF_FEATURE_SEAMLESS_BZ2("/bzip2")
 211                         IF_FEATURE_SEAMLESS_XZ("/xz")
 212                         " magic");
 213
 214         /* Some callers expect this function to "consume" fd
 215          * even if data is not compressed. In this case,
 216          * we return a state with trivial transformer.
 217          */
 218 //      USE_FOR_MMU(xstate->xformer = copy_stream;)
 219 //      USE_FOR_NOMMU(xstate->xformer_prog = "cat";)
 220         /* fall through to seeking bck over bytes we read earlier */
 221
 222  USE_FOR_NOMMU(found_magic:)
 223         /* NOMMU version of fork_transformer execs
 224          * an external unzipper that wants
 225          * file position at the start of the file.
 226          */
 227         xlseek(fd, offset, SEEK_CUR);
 228
 229  USE_FOR_MMU(found_magic:)
 230         /* In MMU case, if magic was found, seeking back is not necessary */
 231
 232         return xstate;
 233 }
 234
 235 /* Used by e.g. rpm which gives us a fd without filename,
 236  * thus we can't guess the format from filename's extension.
 237  */
 238 int FAST_FUNC setup_unzip_on_fd(int fd, int fail_if_not_compressed)
 239 {
 240         transformer_state_t *xstate = setup_transformer_on_fd(fd, fail_if_not_compressed);
 241
 242         if (!xstate || !xstate->xformer) {
 243                 free(xstate);
 244                 return 1;
 245         }
 246
 247 # if BB_MMU
 248         fork_transformer_with_no_sig(xstate->src_fd, xstate->xformer);
 249 # else
 250         fork_transformer_with_sig(xstate->src_fd, xstate->xformer, xstate->xformer_prog);
 251 # endif
 252         free(xstate);
 253         return 0;
 254 }
 255
 256 static transformer_state_t *open_transformer(const char *fname, int fail_if_not_compressed)
 257 {
 258         transformer_state_t *xstate;
 259         int fd;
 260
 261         fd = open(fname, O_RDONLY);
 262         if (fd < 0)
 263                 return NULL;
 264
 265         if (ENABLE_FEATURE_SEAMLESS_LZMA) {
 266                 /* .lzma has no header/signature, can only detect it by extension */
 267                 char *sfx = strrchr(fname, '.');
 268                 if (sfx && strcmp(sfx+1, "lzma") == 0) {
 269                         xstate = xzalloc(sizeof(*xstate));
 270                         xstate->src_fd = fd;
 271                         xstate->xformer = unpack_lzma_stream;
 272                         USE_FOR_NOMMU(xstate->xformer_prog = "unlzma";)
 273                         return xstate;
 274                 }
 275         }
 276
 277         xstate = setup_transformer_on_fd(fd, fail_if_not_compressed);
 278
 279         return xstate;
 280 }
 281
 282 int FAST_FUNC open_zipped(const char *fname, int fail_if_not_compressed)
 283 {
 284         int fd;
 285         transformer_state_t *xstate;
 286
 287         xstate = open_transformer(fname, fail_if_not_compressed);
 288         if (!xstate)
 289                 return -1;
 290
 291         fd = xstate->src_fd;
 292         if (xstate->xformer) {
 293 # if BB_MMU
 294                 fork_transformer_with_no_sig(xstate->src_fd, xstate->xformer);
 295 # else
 296                 fork_transformer_with_sig(xstate->src_fd, xstate->xformer, xstate->xformer_prog);
 297 # endif
 298         }
 299         /* else: the file is not compressed */
 300
 301         free(xstate);
 302         return fd;
 303 }
 304
 305 void* FAST_FUNC xmalloc_open_zipped_read_close(const char *fname, size_t *maxsz_p)
 306 {
 307 # if 1
 308         transformer_state_t *xstate;
 309         char *image;
 310
 311         xstate = open_transformer(fname, /*fail_if_not_compressed:*/ 0);
 312         if (!xstate) /* file open error */
 313                 return NULL;
 314
 315         image = NULL;
 316         if (xstate->xformer) {
 317                 /* In-memory decompression */
 318                 xstate->mem_output_size_max = maxsz_p ? *maxsz_p : (size_t)(INT_MAX - 4095);
 319                 xstate->xformer(xstate);
 320                 if (xstate->mem_output_buf) {
 321                         image = xstate->mem_output_buf;
 322                         if (maxsz_p)
 323                                 *maxsz_p = xstate->mem_output_size;
 324                 }
 325         } else {
 326                 /* File is not compressed */
 327                 image = xmalloc_read(xstate->src_fd, maxsz_p);
 328         }
 329
 330         if (!image)
 331                 bb_perror_msg("read error from '%s'", fname);
 332         close(xstate->src_fd);
 333         free(xstate);
 334         return image;
 335 # else
 336         /* This version forks a subprocess - much more expensive */
 337         int fd;
 338         char *image;
 339
 340         fd = open_zipped(fname, /*fail_if_not_compressed:*/ 0);
 341         if (fd < 0)
 342                 return NULL;
 343
 344         image = xmalloc_read(fd, maxsz_p);
 345         if (!image)
 346                 bb_perror_msg("read error from '%s'", fname);
 347         close(fd);
 348         return image;
 349 # endif
 350 }
 351
 352 #endif /* SEAMLESS_COMPRESSION */