1 /*
2 * Copyright (c) Ian F. Darwin 1986-1995.
3 * Software written by Ian F. Darwin and others;
4 * maintained 1995-present by Christos Zoulas and others.
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 immediately at the beginning of the file, without modification,
11 * this list of conditions, and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
20 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28 /*
29 * compress routines:
30 * zmagic() - returns 0 if not recognized, uncompresses and prints
31 * information if recognized
32 * uncompress(method, old, n, newch) - uncompress old into new,
33 * using method, return sizeof new
34 */
35 #include "file.h"
36
37 #ifndef lint
38 FILE_RCSID("@(#)$File: compress.c,v 1.104 2017/03/29 15:57:48 christos Exp $")
39 #endif
40
41 #include "magic.h"
42 #include <stdlib.h>
43 #ifdef HAVE_UNISTD_H
44 #include <unistd.h>
45 #endif
46 #include <string.h>
47 #include <errno.h>
48 #ifdef HAVE_SIGNAL_H
49 #include <signal.h>
50 # ifndef HAVE_SIG_T
51 typedef void (*sig_t)(int);
52 # endif /* HAVE_SIG_T */
53 #endif
54 #ifndef PHP_WIN32
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(PHP_FILEINFO_UNCOMPRESS)
64 #define BUILTIN_DECOMPRESS
65 #include <zlib.h>
66 #endif
67
68 #undef FIONREAD
69
70 #define gzip_flags "-cd"
71 #define lrzip_flags "-do"
72 #define lzip_flags gzip_flags
73
74 static const char *gzip_args[] = {
75 "gzip", gzip_flags, NULL
76 };
77 static const char *uncompress_args[] = {
78 "uncompress", "-c", NULL
79 };
80 static const char *bzip2_args[] = {
81 "bzip2", "-cd", NULL
82 };
83 static const char *lzip_args[] = {
84 "lzip", lzip_flags, NULL
85 };
86 static const char *xz_args[] = {
87 "xz", "-cd", NULL
88 };
89 static const char *lrzip_args[] = {
90 "lrzip", lrzip_flags, NULL
91 };
92 static const char *lz4_args[] = {
93 "lz4", "-cd", NULL
94 };
95 static const char *zstd_args[] = {
96 "zstd", "-cd", NULL
97 };
98
99 private const struct {
100 const void *magic;
101 size_t maglen;
102 const char **argv;
103 } compr[] = {
104 { "\037\235", 2, gzip_args }, /* compressed */
105 /* Uncompress can get stuck; so use gzip first if we have it
106 * Idea from Damien Clark, thanks! */
107 { "\037\235", 2, uncompress_args }, /* compressed */
108 { "\037\213", 2, gzip_args }, /* gzipped */
109 { "\037\236", 2, gzip_args }, /* frozen */
110 { "\037\240", 2, gzip_args }, /* SCO LZH */
111 /* the standard pack utilities do not accept standard input */
112 { "\037\036", 2, gzip_args }, /* packed */
113 { "PK\3\4", 4, gzip_args }, /* pkzipped, */
114 /* ...only first file examined */
115 { "BZh", 3, bzip2_args }, /* bzip2-ed */
116 { "LZIP", 4, lzip_args }, /* lzip-ed */
117 { "\3757zXZ\0", 6, xz_args }, /* XZ Utils */
118 { "LRZI", 4, lrzip_args }, /* LRZIP */
119 { "\004\"M\030",4, lz4_args }, /* LZ4 */
120 { "\x28\xB5\x2F\xFD", 4, zstd_args }, /* zstd */
121 #ifdef ZLIBSUPPORT
122 { RCAST(const void *, zlibcmp), 0, zlib_args }, /* zlib */
123 #endif
124 };
125
126 #define OKDATA 0
127 #define NODATA 1
128 #define ERRDATA 2
129
130 private ssize_t swrite(int, const void *, size_t);
131 #ifdef PHP_FILEINFO_UNCOMPRESS
132 private size_t ncompr = sizeof(compr) / sizeof(compr[0]);
133 private int uncompressbuf(int, size_t, size_t, const unsigned char *,
134 unsigned char **, size_t *);
135 #ifdef BUILTIN_DECOMPRESS
136 private int uncompresszlib(const unsigned char *, unsigned char **, size_t,
137 size_t *, int);
138 private int uncompressgzipped(const unsigned char *, unsigned char **, size_t,
139 size_t *);
140 #endif
141 static int makeerror(unsigned char **, size_t *, const char *, ...);
142 private const char *methodname(size_t);
143
144 protected int
file_zmagic(struct magic_set * ms,int fd,const char * name,const unsigned char * buf,size_t nbytes)145 file_zmagic(struct magic_set *ms, int fd, const char *name,
146 const unsigned char *buf, size_t nbytes)
147 {
148 unsigned char *newbuf = NULL;
149 size_t i, nsz;
150 char *rbuf;
151 file_pushbuf_t *pb;
152 int urv, prv, rv = 0;
153 int mime = ms->flags & MAGIC_MIME;
154 #ifdef HAVE_SIGNAL_H
155 sig_t osigpipe;
156 #endif
157
158 if ((ms->flags & MAGIC_COMPRESS) == 0)
159 return 0;
160
161 #ifdef HAVE_SIGNAL_H
162 osigpipe = signal(SIGPIPE, SIG_IGN);
163 #endif
164 for (i = 0; i < ncompr; i++) {
165 int zm;
166 if (nbytes < compr[i].maglen)
167 continue;
168 #ifdef ZLIBSUPPORT
169 if (compr[i].maglen == 0)
170 zm = (RCAST(int (*)(const unsigned char *),
171 CCAST(void *, compr[i].magic)))(buf);
172 else
173 #endif
174 zm = memcmp(buf, compr[i].magic, compr[i].maglen) == 0;
175
176 if (!zm)
177 continue;
178 nsz = nbytes;
179 urv = uncompressbuf(fd, ms->bytes_max, i, buf, &newbuf, &nsz);
180 DPRINTF("uncompressbuf = %d, %s, %zu\n", urv, (char *)newbuf,
181 nsz);
182 switch (urv) {
183 case OKDATA:
184 case ERRDATA:
185
186 ms->flags &= ~MAGIC_COMPRESS;
187 if (urv == ERRDATA)
188 prv = file_printf(ms, "%s ERROR: %s",
189 methodname(i), newbuf);
190 else
191 prv = file_buffer(ms, -1, name, newbuf, nsz);
192 if (prv == -1)
193 goto error;
194 rv = 1;
195 if ((ms->flags & MAGIC_COMPRESS_TRANSP) != 0)
196 goto out;
197 if (mime != MAGIC_MIME && mime != 0)
198 goto out;
199 if ((file_printf(ms,
200 mime ? " compressed-encoding=" : " (")) == -1)
201 goto error;
202 if ((pb = file_push_buffer(ms)) == NULL)
203 goto error;
204 /*
205 * XXX: If file_buffer fails here, we overwrite
206 * the compressed text. FIXME.
207 */
208 if (file_buffer(ms, -1, NULL, buf, nbytes) == -1)
209 goto error;
210 if ((rbuf = file_pop_buffer(ms, pb)) != NULL) {
211 if (file_printf(ms, "%s", rbuf) == -1) {
212 efree(rbuf);
213 goto error;
214 }
215 efree(rbuf);
216 }
217 if (!mime && file_printf(ms, ")") == -1)
218 goto error;
219 /*FALLTHROUGH*/
220 case NODATA:
221 break;
222 default:
223 abort();
224 /*NOTREACHED*/
225 error:
226 rv = -1;
227 break;
228 }
229 }
230 out:
231 DPRINTF("rv = %d\n", rv);
232
233 #ifdef HAVE_SIGNAL_H
234 (void)signal(SIGPIPE, osigpipe);
235 #endif
236 if (newbuf)
237 efree(newbuf);
238 ms->flags |= MAGIC_COMPRESS;
239 DPRINTF("Zmagic returns %d\n", rv);
240 return rv;
241 }
242 #endif
243 /*
244 * `safe' write for sockets and pipes.
245 */
246 private ssize_t
swrite(int fd,const void * buf,size_t n)247 swrite(int fd, const void *buf, size_t n)
248 {
249 ssize_t rv;
250 size_t rn = n;
251
252 do
253 switch (rv = write(fd, buf, n)) {
254 case -1:
255 if (errno == EINTR)
256 continue;
257 return -1;
258 default:
259 n -= rv;
260 buf = CAST(const char *, buf) + rv;
261 break;
262 }
263 while (n > 0);
264 return rn;
265 }
266
267
268 /*
269 * `safe' read for sockets and pipes.
270 */
271 protected ssize_t
sread(int fd,void * buf,size_t n,int canbepipe)272 sread(int fd, void *buf, size_t n, int canbepipe)
273 {
274 ssize_t rv;
275 #ifdef FIONREAD
276 int t = 0;
277 #endif
278 size_t rn = n;
279
280 if (fd == STDIN_FILENO)
281 goto nocheck;
282
283 #ifdef FIONREAD
284 if (canbepipe && (ioctl(fd, FIONREAD, &t) == -1 || t == 0)) {
285 #ifdef FD_ZERO
286 ssize_t cnt;
287 for (cnt = 0;; cnt++) {
288 fd_set check;
289 struct timeval tout = {0, 100 * 1000};
290 int selrv;
291
292 FD_ZERO(&check);
293 FD_SET(fd, &check);
294
295 /*
296 * Avoid soft deadlock: do not read if there
297 * is nothing to read from sockets and pipes.
298 */
299 selrv = select(fd + 1, &check, NULL, NULL, &tout);
300 if (selrv == -1) {
301 if (errno == EINTR || errno == EAGAIN)
302 continue;
303 } else if (selrv == 0 && cnt >= 5) {
304 return 0;
305 } else
306 break;
307 }
308 #endif
309 (void)ioctl(fd, FIONREAD, &t);
310 }
311
312 if (t > 0 && (size_t)t < n) {
313 n = t;
314 rn = n;
315 }
316 #endif
317
318 nocheck:
319 do
320 switch ((rv = FINFO_READ_FUNC(fd, buf, n))) {
321 case -1:
322 if (errno == EINTR)
323 continue;
324 return -1;
325 case 0:
326 return rn - n;
327 default:
328 n -= rv;
329 buf = CAST(char *, CCAST(void *, buf)) + rv;
330 break;
331 }
332 while (n > 0);
333 return rn;
334 }
335
336 protected int
file_pipe2file(struct magic_set * ms,int fd,const void * startbuf,size_t nbytes)337 file_pipe2file(struct magic_set *ms, int fd, const void *startbuf,
338 size_t nbytes)
339 {
340 char buf[4096];
341 ssize_t r;
342 int tfd;
343
344 (void)strlcpy(buf, "/tmp/file.XXXXXX", sizeof buf);
345 #ifndef HAVE_MKSTEMP
346 {
347 char *ptr = mktemp(buf);
348 tfd = open(ptr, O_RDWR|O_TRUNC|O_EXCL|O_CREAT, 0600);
349 r = errno;
350 (void)unlink(ptr);
351 errno = r;
352 }
353 #else
354 {
355 int te;
356 tfd = mkstemp(buf);
357 te = errno;
358 (void)unlink(buf);
359 errno = te;
360 }
361 #endif
362 if (tfd == -1) {
363 file_error(ms, errno,
364 "cannot create temporary file for pipe copy");
365 return -1;
366 }
367
368 if (swrite(tfd, startbuf, nbytes) != (ssize_t)nbytes)
369 r = 1;
370 else {
371 while ((r = sread(fd, buf, sizeof(buf), 1)) > 0)
372 if (swrite(tfd, buf, (size_t)r) != r)
373 break;
374 }
375
376 switch (r) {
377 case -1:
378 file_error(ms, errno, "error copying from pipe to temp file");
379 return -1;
380 case 0:
381 break;
382 default:
383 file_error(ms, errno, "error while writing to temp file");
384 return -1;
385 }
386
387 /*
388 * We duplicate the file descriptor, because fclose on a
389 * tmpfile will delete the file, but any open descriptors
390 * can still access the phantom inode.
391 */
392 if ((fd = dup2(tfd, fd)) == -1) {
393 file_error(ms, errno, "could not dup descriptor for temp file");
394 return -1;
395 }
396 (void)close(tfd);
397 if (FINFO_LSEEK_FUNC(fd, (zend_off_t)0, SEEK_SET) == (zend_off_t)-1) {
398 file_badseek(ms);
399 return -1;
400 }
401 return fd;
402 }
403
404 #ifdef PHP_FILEINFO_UNCOMPRESS
405 #ifdef BUILTIN_DECOMPRESS
406
407 #define FHCRC (1 << 1)
408 #define FEXTRA (1 << 2)
409 #define FNAME (1 << 3)
410 #define FCOMMENT (1 << 4)
411
412
413 private int
uncompressgzipped(const unsigned char * old,unsigned char ** newch,size_t bytes_max,size_t * n)414 uncompressgzipped(const unsigned char *old, unsigned char **newch,
415 size_t bytes_max, size_t *n)
416 {
417 unsigned char flg = old[3];
418 size_t data_start = 10;
419
420 if (flg & FEXTRA) {
421 if (data_start + 1 >= *n)
422 goto err;
423 data_start += 2 + old[data_start] + old[data_start + 1] * 256;
424 }
425 if (flg & FNAME) {
426 while(data_start < *n && old[data_start])
427 data_start++;
428 data_start++;
429 }
430 if (flg & FCOMMENT) {
431 while(data_start < *n && old[data_start])
432 data_start++;
433 data_start++;
434 }
435 if (flg & FHCRC)
436 data_start += 2;
437
438 if (data_start >= *n)
439 goto err;
440
441 *n -= data_start;
442 old += data_start;
443 return uncompresszlib(old, newch, bytes_max, n, 0);
444 err:
445 return makeerror(newch, n, "File too short");
446 }
447
448 private int
uncompresszlib(const unsigned char * old,unsigned char ** newch,size_t bytes_max,size_t * n,int zlib)449 uncompresszlib(const unsigned char *old, unsigned char **newch,
450 size_t bytes_max, size_t *n, int zlib)
451 {
452 int rc;
453 z_stream z;
454
455 if ((*newch = CAST(unsigned char *, emalloc(bytes_max + 1))) == NULL)
456 return makeerror(newch, n, "No buffer, %s", strerror(errno));
457
458 z.next_in = CCAST(Bytef *, old);
459 z.avail_in = CAST(uint32_t, *n);
460 z.next_out = *newch;
461 z.avail_out = CAST(unsigned int, bytes_max);
462 z.zalloc = Z_NULL;
463 z.zfree = Z_NULL;
464 z.opaque = Z_NULL;
465
466 /* LINTED bug in header macro */
467 rc = zlib ? inflateInit(&z) : inflateInit2(&z, -15);
468 if (rc != Z_OK)
469 goto err;
470
471 rc = inflate(&z, Z_SYNC_FLUSH);
472 if (rc != Z_OK && rc != Z_STREAM_END)
473 goto err;
474
475 *n = (size_t)z.total_out;
476 rc = inflateEnd(&z);
477 if (rc != Z_OK)
478 goto err;
479
480 /* let's keep the nul-terminate tradition */
481 (*newch)[*n] = '\0';
482
483 return OKDATA;
484 err:
485 strlcpy((char *)*newch, z.msg ? z.msg : zError(rc), bytes_max);
486 *n = strlen((char *)*newch);
487 return ERRDATA;
488 }
489 #endif
490
491 static int
makeerror(unsigned char ** buf,size_t * len,const char * fmt,...)492 makeerror(unsigned char **buf, size_t *len, const char *fmt, ...)
493 {
494 char *msg;
495 va_list ap;
496 int rv;
497
498 va_start(ap, fmt);
499 rv = vasprintf(&msg, fmt, ap);
500 va_end(ap);
501 if (rv < 0) {
502 *buf = NULL;
503 *len = 0;
504 return NODATA;
505 }
506 *buf = (unsigned char *)msg;
507 *len = strlen(msg);
508 return ERRDATA;
509 }
510
511 static void
closefd(int * fd,size_t i)512 closefd(int *fd, size_t i)
513 {
514 if (fd[i] == -1)
515 return;
516 (void) close(fd[i]);
517 fd[i] = -1;
518 }
519
520 static void
closep(int * fd)521 closep(int *fd)
522 {
523 size_t i;
524 for (i = 0; i < 2; i++)
525 closefd(fd, i);
526 }
527
528 static void
copydesc(int i,int * fd)529 copydesc(int i, int *fd)
530 {
531 int j = fd[i == STDIN_FILENO ? 0 : 1];
532 if (j == i)
533 return;
534 if (dup2(j, i) == -1) {
535 DPRINTF("dup(%d, %d) failed (%s)\n", j, i, strerror(errno));
536 exit(1);
537 }
538 closep(fd);
539 }
540
541 static void
writechild(int fdp[3][2],const void * old,size_t n)542 writechild(int fdp[3][2], const void *old, size_t n)
543 {
544 int status;
545
546 closefd(fdp[STDIN_FILENO], 0);
547 /*
548 * fork again, to avoid blocking because both
549 * pipes filled
550 */
551 switch (fork()) {
552 case 0: /* child */
553 closefd(fdp[STDOUT_FILENO], 0);
554 if (swrite(fdp[STDIN_FILENO][1], old, n) != (ssize_t)n) {
555 DPRINTF("Write failed (%s)\n", strerror(errno));
556 exit(1);
557 }
558 exit(0);
559 /*NOTREACHED*/
560
561 case -1:
562 DPRINTF("Fork failed (%s)\n", strerror(errno));
563 exit(1);
564 /*NOTREACHED*/
565
566 default: /* parent */
567 if (wait(&status) == -1) {
568 DPRINTF("Wait failed (%s)\n", strerror(errno));
569 exit(1);
570 }
571 DPRINTF("Grandchild wait return %#x\n", status);
572 }
573 closefd(fdp[STDIN_FILENO], 1);
574 }
575
576 static ssize_t
filter_error(unsigned char * ubuf,ssize_t n)577 filter_error(unsigned char *ubuf, ssize_t n)
578 {
579 char *p;
580 char *buf;
581
582 ubuf[n] = '\0';
583 buf = (char *)ubuf;
584 while (isspace((unsigned char)*buf))
585 buf++;
586 DPRINTF("Filter error[[[%s]]]\n", buf);
587 if ((p = strchr((char *)buf, '\n')) != NULL)
588 *p = '\0';
589 if ((p = strchr((char *)buf, ';')) != NULL)
590 *p = '\0';
591 if ((p = strrchr((char *)buf, ':')) != NULL) {
592 ++p;
593 while (isspace((unsigned char)*p))
594 p++;
595 n = strlen(p);
596 memmove(ubuf, p, CAST(size_t, n + 1));
597 }
598 DPRINTF("Filter error after[[[%s]]]\n", (char *)ubuf);
599 if (islower(*ubuf))
600 *ubuf = toupper(*ubuf);
601 return n;
602 }
603
604 private const char *
methodname(size_t method)605 methodname(size_t method)
606 {
607 #ifdef BUILTIN_DECOMPRESS
608 /* FIXME: This doesn't cope with bzip2 */
609 if (method == 2 || compr[method].maglen == 0)
610 return "zlib";
611 #endif
612 return compr[method].argv[0];
613 }
614
615 private int
uncompressbuf(int fd,size_t bytes_max,size_t method,const unsigned char * old,unsigned char ** newch,size_t * n)616 uncompressbuf(int fd, size_t bytes_max, size_t method, const unsigned char *old,
617 unsigned char **newch, size_t* n)
618 {
619 int fdp[3][2];
620 int status, rv;
621 size_t i;
622 ssize_t r;
623
624 #ifdef BUILTIN_DECOMPRESS
625 /* FIXME: This doesn't cope with bzip2 */
626 if (method == 2)
627 return uncompressgzipped(old, newch, bytes_max, n);
628 if (compr[method].maglen == 0)
629 return uncompresszlib(old, newch, bytes_max, n, 1);
630 #endif
631 (void)fflush(stdout);
632 (void)fflush(stderr);
633
634 for (i = 0; i < __arraycount(fdp); i++)
635 fdp[i][0] = fdp[i][1] = -1;
636
637 if ((fd == -1 && pipe(fdp[STDIN_FILENO]) == -1) ||
638 pipe(fdp[STDOUT_FILENO]) == -1 || pipe(fdp[STDERR_FILENO]) == -1) {
639 closep(fdp[STDIN_FILENO]);
640 closep(fdp[STDOUT_FILENO]);
641 return makeerror(newch, n, "Cannot create pipe, %s",
642 strerror(errno));
643 }
644 switch (fork()) {
645 case 0: /* child */
646 if (fd != -1) {
647 fdp[STDIN_FILENO][0] = fd;
648 (void) lseek(fd, (off_t)0, SEEK_SET);
649 }
650
651 for (i = 0; i < __arraycount(fdp); i++)
652 copydesc(CAST(int, i), fdp[i]);
653
654 (void)execvp(compr[method].argv[0],
655 (char *const *)(intptr_t)compr[method].argv);
656 dprintf(STDERR_FILENO, "exec `%s' failed, %s",
657 compr[method].argv[0], strerror(errno));
658 exit(1);
659 /*NOTREACHED*/
660 case -1:
661 return makeerror(newch, n, "Cannot fork, %s",
662 strerror(errno));
663
664 default: /* parent */
665 for (i = 1; i < __arraycount(fdp); i++)
666 closefd(fdp[i], 1);
667
668 /* Write the buffer data to the child, if we don't have fd */
669 if (fd == -1)
670 writechild(fdp, old, *n);
671
672 *newch = CAST(unsigned char *, emalloc(bytes_max + 1));
673 if (*newch == NULL) {
674 rv = makeerror(newch, n, "No buffer, %s",
675 strerror(errno));
676 goto err;
677 }
678 rv = OKDATA;
679 if ((r = sread(fdp[STDOUT_FILENO][0], *newch, bytes_max, 0)) > 0)
680 break;
681 DPRINTF("Read stdout failed %d (%s)\n", fdp[STDOUT_FILENO][0],
682 r != -1 ? strerror(errno) : "no data");
683
684 rv = ERRDATA;
685 if (r == 0 &&
686 (r = sread(fdp[STDERR_FILENO][0], *newch, bytes_max, 0)) > 0)
687 {
688 r = filter_error(*newch, r);
689 break;
690 }
691 efree(*newch);
692 if (r == 0)
693 rv = makeerror(newch, n, "Read failed, %s",
694 strerror(errno));
695 else
696 rv = makeerror(newch, n, "No data");
697 goto err;
698 }
699 }
700 #endif /* if PHP_FILEINFO_UNCOMPRESS */
701
