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