external/bsd/file/dist/src/compress.c

   1 /*      $NetBSD: compress.c,v 1.4 2011/09/16 21:06:26 christos Exp $    */
   2
   3 /*
   4  * Copyright (c) Ian F. Darwin 1986-1995.
   5  * Software written by Ian F. Darwin and others;
   6  * maintained 1995-present by Christos Zoulas and others.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice immediately at the beginning of the file, without modification,
  13  *    this list of conditions, and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  22  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  */
  30 /*
  31  * compress routines:
  32  *      zmagic() - returns 0 if not recognized, uncompresses and prints
  33  *                 information if recognized
  34  *      uncompress(method, old, n, newch) - uncompress old into new,
  35  *                                          using method, return sizeof new
  36  */
  37 #include "file.h"
  38
  39 #ifndef lint
  40 #if 0
  41 FILE_RCSID("@(#)$File: compress.c,v 1.67 2011/09/01 12:12:37 christos Exp $")
  42 #else
  43 __RCSID("$NetBSD: compress.c,v 1.4 2011/09/16 21:06:26 christos Exp $");
  44 #endif
  45 #endif
  46
  47 #include "magic.h"
  48 #include <stdlib.h>
  49 #ifdef HAVE_UNISTD_H
  50 #include <unistd.h>
  51 #endif
  52 #include <string.h>
  53 #include <errno.h>
  54 #ifndef __MINGW32__
  55 #include <sys/ioctl.h>
  56 #endif
  57 #ifdef HAVE_SYS_WAIT_H
  58 #include <sys/wait.h>
  59 #endif
  60 #if defined(HAVE_SYS_TIME_H)
  61 #include <sys/time.h>
  62 #endif
  63 #if defined(HAVE_ZLIB_H) && defined(HAVE_LIBZ)
  64 #define BUILTIN_DECOMPRESS
  65 #include <zlib.h>
  66 #endif
  67
  68 private const struct {
  69         const char magic[8];
  70         size_t maglen;
  71         const char *argv[3];
  72         int silent;
  73 } compr[] = {
  74         { "\037\235", 2, { "gzip", "-cdq", NULL }, 1 },         /* compressed */
  75         /* Uncompress can get stuck; so use gzip first if we have it
  76          * Idea from Damien Clark, thanks! */
  77         { "\037\235", 2, { "uncompress", "-c", NULL }, 1 },     /* compressed */
  78         { "\037\213", 2, { "gzip", "-cdq", NULL }, 1 },         /* gzipped */
  79         { "\037\236", 2, { "gzip", "-cdq", NULL }, 1 },         /* frozen */
  80         { "\037\240", 2, { "gzip", "-cdq", NULL }, 1 },         /* SCO LZH */
  81         /* the standard pack utilities do not accept standard input */
  82         { "\037\036", 2, { "gzip", "-cdq", NULL }, 0 },         /* packed */
  83         { "PK\3\4",   4, { "gzip", "-cdq", NULL }, 1 },         /* pkzipped, */
  84                                             /* ...only first file examined */
  85         { "BZh",      3, { "bzip2", "-cd", NULL }, 1 },         /* bzip2-ed */
  86         { "LZIP",     4, { "lzip", "-cdq", NULL }, 1 },
  87         { "\3757zXZ\0",6,{ "xz", "-cd", NULL }, 1 },            /* XZ Utils */
  88         { "LRZI",     4, { "lrzip", "-dqo-", NULL }, 1 },       /* LRZIP */
  89 };
  90
  91 #define NODATA ((size_t)~0)
  92
  93 private ssize_t swrite(int, const void *, size_t);
  94 #if HAVE_FORK
  95 private size_t ncompr = sizeof(compr) / sizeof(compr[0]);
  96 private size_t uncompressbuf(struct magic_set *, int, size_t,
  97     const unsigned char *, unsigned char **, size_t);
  98 #ifdef BUILTIN_DECOMPRESS
  99 private size_t uncompressgzipped(struct magic_set *, const unsigned char *,
 100     unsigned char **, size_t);
 101 #endif
 102
 103 protected int
 104 file_zmagic(struct magic_set *ms, int fd, const char *name,
 105     const unsigned char *buf, size_t nbytes)
 106 {
 107         unsigned char *newbuf = NULL;
 108         size_t i, nsz;
 109         int rv = 0;
 110         int mime = ms->flags & MAGIC_MIME;
 111
 112         if ((ms->flags & MAGIC_COMPRESS) == 0)
 113                 return 0;
 114
 115         for (i = 0; i < ncompr; i++) {
 116                 if (nbytes < compr[i].maglen)
 117                         continue;
 118                 if (memcmp(buf, compr[i].magic, compr[i].maglen) == 0 &&
 119                     (nsz = uncompressbuf(ms, fd, i, buf, &newbuf,
 120                     nbytes)) != NODATA) {
 121                         ms->flags &= ~MAGIC_COMPRESS;
 122                         rv = -1;
 123                         if (file_buffer(ms, -1, name, newbuf, nsz) == -1)
 124                                 goto error;
 125
 126                         if (mime == MAGIC_MIME || mime == 0) {
 127                                 if (file_printf(ms, mime ?
 128                                     " compressed-encoding=" : " (") == -1)
 129                                         goto error;
 130                         }
 131
 132                         if ((mime == 0 || mime & MAGIC_MIME_ENCODING) &&
 133                             file_buffer(ms, -1, NULL, buf, nbytes) == -1)
 134                                 goto error;
 135
 136                         if (!mime && file_printf(ms, ")") == -1)
 137                                 goto error;
 138                         rv = 1;
 139                         break;
 140                 }
 141         }
 142 error:
 143         if (newbuf)
 144                 free(newbuf);
 145         ms->flags |= MAGIC_COMPRESS;
 146         return rv;
 147 }
 148 #endif
 149 /*
 150  * `safe' write for sockets and pipes.
 151  */
 152 private ssize_t
 153 swrite(int fd, const void *buf, size_t n)
 154 {
 155         ssize_t rv;
 156         size_t rn = n;
 157
 158         do
 159                 switch (rv = write(fd, buf, n)) {
 160                 case -1:
 161                         if (errno == EINTR)
 162                                 continue;
 163                         return -1;
 164                 default:
 165                         n -= rv;
 166                         buf = CAST(const char *, buf) + rv;
 167                         break;
 168                 }
 169         while (n > 0);
 170         return rn;
 171 }
 172
 173
 174 /*
 175  * `safe' read for sockets and pipes.
 176  */
 177 protected ssize_t
 178 sread(int fd, void *buf, size_t n, int canbepipe __attribute__ ((unused)))
 179 {
 180         ssize_t rv;
 181 #ifdef FD_ZERO
 182         ssize_t cnt;
 183 #endif
 184 #ifdef FIONREAD
 185         int t = 0;
 186 #endif
 187         size_t rn = n;
 188
 189         if (fd == STDIN_FILENO)
 190                 goto nocheck;
 191
 192 #ifdef FIONREAD
 193         if ((canbepipe && (ioctl(fd, FIONREAD, &t) == -1)) || (t == 0)) {
 194 #ifdef FD_ZERO
 195                 for (cnt = 0;; cnt++) {
 196                         fd_set check;
 197                         struct timeval tout = {0, 100 * 1000};
 198                         int selrv;
 199
 200                         FD_ZERO(&check);
 201                         FD_SET(fd, &check);
 202
 203                         /*
 204                          * Avoid soft deadlock: do not read if there
 205                          * is nothing to read from sockets and pipes.
 206                          */
 207                         selrv = select(fd + 1, &check, NULL, NULL, &tout);
 208                         if (selrv == -1) {
 209                                 if (errno == EINTR || errno == EAGAIN)
 210                                         continue;
 211                         } else if (selrv == 0 && cnt >= 5) {
 212                                 return 0;
 213                         } else
 214                                 break;
 215                 }
 216 #endif
 217                 (void)ioctl(fd, FIONREAD, &t);
 218         }
 219
 220         if (t > 0 && (size_t)t < n) {
 221                 n = t;
 222                 rn = n;
 223         }
 224 #endif
 225
 226 nocheck:
 227         do
 228                 switch ((rv = read(fd, buf, n))) {
 229                 case -1:
 230                         if (errno == EINTR)
 231                                 continue;
 232                         return -1;
 233                 case 0:
 234                         return rn - n;
 235                 default:
 236                         n -= rv;
 237                         buf = ((char *)buf) + rv;
 238                         break;
 239                 }
 240         while (n > 0);
 241         return rn;
 242 }
 243
 244 protected int
 245 file_pipe2file(struct magic_set *ms, int fd, const void *startbuf,
 246     size_t nbytes)
 247 {
 248         char buf[4096];
 249         ssize_t r;
 250         int tfd;
 251 #ifdef HAVE_MKSTEMP
 252         int te;
 253 #endif
 254
 255         (void)strlcpy(buf, "/tmp/file.XXXXXX", sizeof buf);
 256 #ifndef HAVE_MKSTEMP
 257         {
 258                 char *ptr = mktemp(buf);
 259                 tfd = open(ptr, O_RDWR|O_TRUNC|O_EXCL|O_CREAT, 0600);
 260                 r = errno;
 261                 (void)unlink(ptr);
 262                 errno = r;
 263         }
 264 #else
 265         tfd = mkstemp(buf);
 266         te = errno;
 267         (void)unlink(buf);
 268         errno = te;
 269 #endif
 270         if (tfd == -1) {
 271                 file_error(ms, errno,
 272                     "cannot create temporary file for pipe copy");
 273                 return -1;
 274         }
 275
 276         if (swrite(tfd, startbuf, nbytes) != (ssize_t)nbytes)
 277                 r = 1;
 278         else {
 279                 while ((r = sread(fd, buf, sizeof(buf), 1)) > 0)
 280                         if (swrite(tfd, buf, (size_t)r) != r)
 281                                 break;
 282         }
 283
 284         switch (r) {
 285         case -1:
 286                 file_error(ms, errno, "error copying from pipe to temp file");
 287                 return -1;
 288         case 0:
 289                 break;
 290         default:
 291                 file_error(ms, errno, "error while writing to temp file");
 292                 return -1;
 293         }
 294
 295         /*
 296          * We duplicate the file descriptor, because fclose on a
 297          * tmpfile will delete the file, but any open descriptors
 298          * can still access the phantom inode.
 299          */
 300         if ((fd = dup2(tfd, fd)) == -1) {
 301                 file_error(ms, errno, "could not dup descriptor for temp file");
 302                 return -1;
 303         }
 304         (void)close(tfd);
 305         if (lseek(fd, (off_t)0, SEEK_SET) == (off_t)-1) {
 306                 file_badseek(ms);
 307                 return -1;
 308         }
 309         return fd;
 310 }
 311 #if HAVE_FORK
 312 #ifdef BUILTIN_DECOMPRESS
 313
 314 #define FHCRC           (1 << 1)
 315 #define FEXTRA          (1 << 2)
 316 #define FNAME           (1 << 3)
 317 #define FCOMMENT        (1 << 4)
 318
 319 private size_t
 320 uncompressgzipped(struct magic_set *ms, const unsigned char *old,
 321     unsigned char **newch, size_t n)
 322 {
 323         unsigned char flg = old[3];
 324         size_t data_start = 10;
 325         z_stream z;
 326         int rc;
 327
 328         if (flg & FEXTRA) {
 329                 if (data_start+1 >= n)
 330                         return 0;
 331                 data_start += 2 + old[data_start] + old[data_start + 1] * 256;
 332         }
 333         if (flg & FNAME) {
 334                 while(data_start < n && old[data_start])
 335                         data_start++;
 336                 data_start++;
 337         }
 338         if(flg & FCOMMENT) {
 339                 while(data_start < n && old[data_start])
 340                         data_start++;
 341                 data_start++;
 342         }
 343         if(flg & FHCRC)
 344                 data_start += 2;
 345
 346         if (data_start >= n)
 347                 return 0;
 348         if ((*newch = CAST(unsigned char *, malloc(HOWMANY + 1))) == NULL) {
 349                 return 0;
 350         }
 351
 352         /* XXX: const castaway, via strchr */
 353         z.next_in = (Bytef *)strchr((const char *)old + data_start,
 354             old[data_start]);
 355         z.avail_in = CAST(uint32_t, (n - data_start));
 356         z.next_out = *newch;
 357         z.avail_out = HOWMANY;
 358         z.zalloc = Z_NULL;
 359         z.zfree = Z_NULL;
 360         z.opaque = Z_NULL;
 361
 362         /* LINTED bug in header macro */
 363         rc = inflateInit2(&z, -15);
 364         if (rc != Z_OK) {
 365                 file_error(ms, 0, "zlib: %s", z.msg);
 366                 return 0;
 367         }
 368
 369         rc = inflate(&z, Z_SYNC_FLUSH);
 370         if (rc != Z_OK && rc != Z_STREAM_END) {
 371                 file_error(ms, 0, "zlib: %s", z.msg);
 372                 return 0;
 373         }
 374
 375         n = (size_t)z.total_out;
 376         (void)inflateEnd(&z);
 377
 378         /* let's keep the nul-terminate tradition */
 379         (*newch)[n] = '\0';
 380
 381         return n;
 382 }
 383 #endif
 384
 385 private size_t
 386 uncompressbuf(struct magic_set *ms, int fd, size_t method,
 387     const unsigned char *old, unsigned char **newch, size_t n)
 388 {
 389         int fdin[2], fdout[2];
 390         ssize_t r;
 391         pid_t pid;
 392
 393 #ifdef BUILTIN_DECOMPRESS
 394         /* FIXME: This doesn't cope with bzip2 */
 395         if (method == 2)
 396                 return uncompressgzipped(ms, old, newch, n);
 397 #endif
 398         (void)fflush(stdout);
 399         (void)fflush(stderr);
 400
 401         if ((fd != -1 && pipe(fdin) == -1) || pipe(fdout) == -1) {
 402                 file_error(ms, errno, "cannot create pipe");
 403                 return NODATA;
 404         }
 405         switch (pid = fork()) {
 406         case 0: /* child */
 407                 (void) close(0);
 408                 if (fd != -1) {
 409                     (void) dup(fd);
 410                     (void) lseek(0, (off_t)0, SEEK_SET);
 411                 } else {
 412                     (void) dup(fdin[0]);
 413                     (void) close(fdin[0]);
 414                     (void) close(fdin[1]);
 415                 }
 416
 417                 (void) close(1);
 418                 (void) dup(fdout[1]);
 419                 (void) close(fdout[0]);
 420                 (void) close(fdout[1]);
 421 #ifndef DEBUG
 422                 if (compr[method].silent)
 423                         (void)close(2);
 424 #endif
 425
 426                 (void)execvp(compr[method].argv[0],
 427                     (char *const *)(intptr_t)compr[method].argv);
 428 #ifdef DEBUG
 429                 (void)fprintf(stderr, "exec `%s' failed (%s)\n",
 430                     compr[method].argv[0], strerror(errno));
 431 #endif
 432                 exit(1);
 433                 /*NOTREACHED*/
 434         case -1:
 435                 file_error(ms, errno, "could not fork");
 436                 return NODATA;
 437
 438         default: /* parent */
 439                 (void) close(fdout[1]);
 440                 if (fd == -1) {
 441                         (void) close(fdin[0]);
 442                         /*
 443                          * fork again, to avoid blocking because both
 444                          * pipes filled
 445                          */
 446                         switch (fork()) {
 447                         case 0: /* child */
 448                                 (void)close(fdout[0]);
 449                                 if (swrite(fdin[1], old, n) != (ssize_t)n) {
 450 #ifdef DEBUG
 451                                         (void)fprintf(stderr,
 452                                             "Write failed (%s)\n",
 453                                             strerror(errno));
 454 #endif
 455                                         exit(1);
 456                                 }
 457                                 exit(0);
 458                                 /*NOTREACHED*/
 459
 460                         case -1:
 461 #ifdef DEBUG
 462                                 (void)fprintf(stderr, "Fork failed (%s)\n",
 463                                     strerror(errno));
 464 #endif
 465                                 exit(1);
 466                                 /*NOTREACHED*/
 467
 468                         default:  /* parent */
 469                                 break;
 470                         }
 471                         (void) close(fdin[1]);
 472                         fdin[1] = -1;
 473                 }
 474
 475                 if ((*newch = (unsigned char *) malloc(HOWMANY + 1)) == NULL) {
 476 #ifdef DEBUG
 477                         (void)fprintf(stderr, "Malloc failed (%s)\n",
 478                             strerror(errno));
 479 #endif
 480                         n = 0;
 481                         goto err;
 482                 }
 483                 if ((r = sread(fdout[0], *newch, HOWMANY, 0)) <= 0) {
 484 #ifdef DEBUG
 485                         (void)fprintf(stderr, "Read failed (%s)\n",
 486                             strerror(errno));
 487 #endif
 488                         free(*newch);
 489                         n = 0;
 490                         newch[0] = '\0';
 491                         goto err;
 492                 } else {
 493                         n = r;
 494                 }
 495                 /* NUL terminate, as every buffer is handled here. */
 496                 (*newch)[n] = '\0';
 497 err:
 498                 if (fdin[1] != -1)
 499                         (void) close(fdin[1]);
 500                 (void) close(fdout[0]);
 501 #ifdef WNOHANG
 502                 while (waitpid(pid, NULL, WNOHANG) != -1)
 503                         continue;
 504 #else
 505                 (void)wait(NULL);
 506 #endif
 507                 (void) close(fdin[0]);
 508
 509                 return n;
 510         }
 511 }
 512 #endif