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_Z
 189          && magic.b16[0] == COMPRESS_MAGIC
 190         ) {
 191                 xstate->xformer = unpack_Z_stream;
 192                 USE_FOR_NOMMU(xstate->xformer_prog = "uncompress";)
 193                 goto found_magic;
 194         }
 195         if (ENABLE_FEATURE_SEAMLESS_BZ2
 196          && magic.b16[0] == BZIP2_MAGIC
 197         ) {
 198                 xstate->xformer = unpack_bz2_stream;
 199                 USE_FOR_NOMMU(xstate->xformer_prog = "bunzip2";)
 200                 goto found_magic;
 201         }
 202         if (ENABLE_FEATURE_SEAMLESS_XZ
 203          && magic.b16[0] == XZ_MAGIC1
 204         ) {
 205                 offset = -6;
 206                 xread(fd, magic.b32, sizeof(magic.b32[0]));
 207                 if (magic.b32[0] == XZ_MAGIC2) {
 208                         xstate->xformer = unpack_xz_stream;
 209                         USE_FOR_NOMMU(xstate->xformer_prog = "unxz";)
 210                         goto found_magic;
 211                 }
 212         }
 213
 214         /* No known magic seen */
 215         if (fail_if_not_compressed)
 216                 bb_error_msg_and_die("no gzip"
 217                         IF_FEATURE_SEAMLESS_BZ2("/bzip2")
 218                         IF_FEATURE_SEAMLESS_XZ("/xz")
 219                         " magic");
 220
 221         /* Some callers expect this function to "consume" fd
 222          * even if data is not compressed. In this case,
 223          * we return a state with trivial transformer.
 224          */
 225 //      USE_FOR_MMU(xstate->xformer = copy_stream;)
 226 //      USE_FOR_NOMMU(xstate->xformer_prog = "cat";)
 227         /* fall through to seeking bck over bytes we read earlier */
 228
 229  USE_FOR_NOMMU(found_magic:)
 230         /* NOMMU version of fork_transformer execs
 231          * an external unzipper that wants
 232          * file position at the start of the file.
 233          */
 234         xlseek(fd, offset, SEEK_CUR);
 235
 236  USE_FOR_MMU(found_magic:)
 237         /* In MMU case, if magic was found, seeking back is not necessary */
 238
 239         return xstate;
 240 }
 241
 242 /* Used by e.g. rpm which gives us a fd without filename,
 243  * thus we can't guess the format from filename's extension.
 244  */
 245 int FAST_FUNC setup_unzip_on_fd(int fd, int fail_if_not_compressed)
 246 {
 247         transformer_state_t *xstate = setup_transformer_on_fd(fd, fail_if_not_compressed);
 248
 249         if (!xstate || !xstate->xformer) {
 250                 free(xstate);
 251                 return 1;
 252         }
 253
 254 # if BB_MMU
 255         fork_transformer_with_no_sig(xstate->src_fd, xstate->xformer);
 256 # else
 257         fork_transformer_with_sig(xstate->src_fd, xstate->xformer, xstate->xformer_prog);
 258 # endif
 259         free(xstate);
 260         return 0;
 261 }
 262
 263 static transformer_state_t *open_transformer(const char *fname, int fail_if_not_compressed)
 264 {
 265         transformer_state_t *xstate;
 266         int fd;
 267
 268         fd = open(fname, O_RDONLY);
 269         if (fd < 0)
 270                 return NULL;
 271
 272         if (ENABLE_FEATURE_SEAMLESS_LZMA) {
 273                 /* .lzma has no header/signature, can only detect it by extension */
 274                 char *sfx = strrchr(fname, '.');
 275                 if (sfx && strcmp(sfx+1, "lzma") == 0) {
 276                         xstate = xzalloc(sizeof(*xstate));
 277                         xstate->src_fd = fd;
 278                         xstate->xformer = unpack_lzma_stream;
 279                         USE_FOR_NOMMU(xstate->xformer_prog = "unlzma";)
 280                         return xstate;
 281                 }
 282         }
 283
 284         xstate = setup_transformer_on_fd(fd, fail_if_not_compressed);
 285
 286         return xstate;
 287 }
 288
 289 int FAST_FUNC open_zipped(const char *fname, int fail_if_not_compressed)
 290 {
 291         int fd;
 292         transformer_state_t *xstate;
 293
 294         xstate = open_transformer(fname, fail_if_not_compressed);
 295         if (!xstate)
 296                 return -1;
 297
 298         fd = xstate->src_fd;
 299         if (xstate->xformer) {
 300 # if BB_MMU
 301                 fork_transformer_with_no_sig(xstate->src_fd, xstate->xformer);
 302 # else
 303                 fork_transformer_with_sig(xstate->src_fd, xstate->xformer, xstate->xformer_prog);
 304 # endif
 305         }
 306         /* else: the file is not compressed */
 307
 308         free(xstate);
 309         return fd;
 310 }
 311
 312 void* FAST_FUNC xmalloc_open_zipped_read_close(const char *fname, size_t *maxsz_p)
 313 {
 314 # if 1
 315         transformer_state_t *xstate;
 316         char *image;
 317
 318         xstate = open_transformer(fname, /*fail_if_not_compressed:*/ 0);
 319         if (!xstate) /* file open error */
 320                 return NULL;
 321
 322         image = NULL;
 323         if (xstate->xformer) {
 324                 /* In-memory decompression */
 325                 xstate->mem_output_size_max = maxsz_p ? *maxsz_p : (size_t)(INT_MAX - 4095);
 326                 xstate->xformer(xstate);
 327                 if (xstate->mem_output_buf) {
 328                         image = xstate->mem_output_buf;
 329                         if (maxsz_p)
 330                                 *maxsz_p = xstate->mem_output_size;
 331                 }
 332         } else {
 333                 /* File is not compressed */
 334                 image = xmalloc_read(xstate->src_fd, maxsz_p);
 335         }
 336
 337         if (!image)
 338                 bb_perror_msg("read error from '%s'", fname);
 339         close(xstate->src_fd);
 340         free(xstate);
 341         return image;
 342 # else
 343         /* This version forks a subprocess - much more expensive */
 344         int fd;
 345         char *image;
 346
 347         fd = open_zipped(fname, /*fail_if_not_compressed:*/ 0);
 348         if (fd < 0)
 349                 return NULL;
 350
 351         image = xmalloc_read(fd, maxsz_p);
 352         if (!image)
 353                 bb_perror_msg("read error from '%s'", fname);
 354         close(fd);
 355         return image;
 356 # endif
 357 }
 358
 359 #endif /* SEAMLESS_COMPRESSION */