compress.c revision 192348 
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
38FILE_RCSID("@(#)$File: compress.c,v 1.63 2009/03/23 14:21:51 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#include <sys/ioctl.h>
49#ifdef HAVE_SYS_WAIT_H
50#include <sys/wait.h>
51#endif
52#if defined(HAVE_SYS_TIME_H)
53#include <sys/time.h>
54#endif
55#if defined(HAVE_ZLIB_H) && defined(HAVE_LIBZ)
56#define BUILTIN_DECOMPRESS
57#include <zlib.h>
58#endif
59
60private const struct {
61	const char magic[8];
62	size_t maglen;
63	const char *argv[3];
64	int silent;
65} compr[] = {
66	{ "\037\235", 2, { "gzip", "-cdq", NULL }, 1 },		/* compressed */
67	/* Uncompress can get stuck; so use gzip first if we have it
68	 * Idea from Damien Clark, thanks! */
69	{ "\037\235", 2, { "uncompress", "-c", NULL }, 1 },	/* compressed */
70	{ "\037\213", 2, { "gzip", "-cdq", NULL }, 1 },		/* gzipped */
71	{ "\037\236", 2, { "gzip", "-cdq", NULL }, 1 },		/* frozen */
72	{ "\037\240", 2, { "gzip", "-cdq", NULL }, 1 },		/* SCO LZH */
73	/* the standard pack utilities do not accept standard input */
74	{ "\037\036", 2, { "gzip", "-cdq", NULL }, 0 },		/* packed */
75	{ "PK\3\4",   4, { "gzip", "-cdq", NULL }, 1 },		/* pkzipped, */
76					    /* ...only first file examined */
77	{ "BZh",      3, { "bzip2", "-cd", NULL }, 1 },		/* bzip2-ed */
78	{ "LZIP",     4, { "lzip", "-cdq", NULL }, 1 },
79 	{ "\3757zXZ\0",6,{ "xz", "-cd", NULL }, 1 },		/* XZ Utils */
80};
81
82private size_t ncompr = sizeof(compr) / sizeof(compr[0]);
83
84#define NODATA ((size_t)~0)
85
86
87private ssize_t swrite(int, const void *, size_t);
88private size_t uncompressbuf(struct magic_set *, int, size_t,
89    const unsigned char *, unsigned char **, size_t);
90#ifdef BUILTIN_DECOMPRESS
91private size_t uncompressgzipped(struct magic_set *, const unsigned char *,
92    unsigned char **, size_t);
93#endif
94
95protected int
96file_zmagic(struct magic_set *ms, int fd, const char *name,
97    const unsigned char *buf, size_t nbytes)
98{
99	unsigned char *newbuf = NULL;
100	size_t i, nsz;
101	int rv = 0;
102	int mime = ms->flags & MAGIC_MIME;
103
104	if ((ms->flags & MAGIC_COMPRESS) == 0)
105		return 0;
106
107	for (i = 0; i < ncompr; i++) {
108		if (nbytes < compr[i].maglen)
109			continue;
110		if (memcmp(buf, compr[i].magic, compr[i].maglen) == 0 &&
111		    (nsz = uncompressbuf(ms, fd, i, buf, &newbuf,
112		    nbytes)) != NODATA) {
113			ms->flags &= ~MAGIC_COMPRESS;
114			rv = -1;
115			if (file_buffer(ms, -1, name, newbuf, nsz) == -1)
116				goto error;
117
118			if (mime == MAGIC_MIME || mime == 0) {
119				if (file_printf(ms, mime ?
120				    " compressed-encoding=" : " (") == -1)
121					goto error;
122			}
123
124			if ((mime == 0 || mime & MAGIC_MIME_ENCODING) &&
125			    file_buffer(ms, -1, NULL, buf, nbytes) == -1)
126				goto error;
127
128			if (!mime && file_printf(ms, ")") == -1)
129				goto error;
130			rv = 1;
131			break;
132		}
133	}
134error:
135	if (newbuf)
136		free(newbuf);
137	ms->flags |= MAGIC_COMPRESS;
138	return rv;
139}
140
141/*
142 * `safe' write for sockets and pipes.
143 */
144private ssize_t
145swrite(int fd, const void *buf, size_t n)
146{
147	int rv;
148	size_t rn = n;
149
150	do
151		switch (rv = write(fd, buf, n)) {
152		case -1:
153			if (errno == EINTR)
154				continue;
155			return -1;
156		default:
157			n -= rv;
158			buf = ((const char *)buf) + rv;
159			break;
160		}
161	while (n > 0);
162	return rn;
163}
164
165
166/*
167 * `safe' read for sockets and pipes.
168 */
169protected ssize_t
170sread(int fd, void *buf, size_t n, int canbepipe)
171{
172	int rv, cnt;
173#ifdef FIONREAD
174	int t = 0;
175#endif
176	size_t rn = n;
177
178	if (fd == STDIN_FILENO)
179		goto nocheck;
180
181#ifdef FIONREAD
182	if ((canbepipe && (ioctl(fd, FIONREAD, &t) == -1)) || (t == 0)) {
183#ifdef FD_ZERO
184		for (cnt = 0;; cnt++) {
185			fd_set check;
186			struct timeval tout = {0, 100 * 1000};
187			int selrv;
188
189			FD_ZERO(&check);
190			FD_SET(fd, &check);
191
192			/*
193			 * Avoid soft deadlock: do not read if there
194			 * is nothing to read from sockets and pipes.
195			 */
196			selrv = select(fd + 1, &check, NULL, NULL, &tout);
197			if (selrv == -1) {
198				if (errno == EINTR || errno == EAGAIN)
199					continue;
200			} else if (selrv == 0 && cnt >= 5) {
201				return 0;
202			} else
203				break;
204		}
205#endif
206		(void)ioctl(fd, FIONREAD, &t);
207	}
208
209	if (t > 0 && (size_t)t < n) {
210		n = t;
211		rn = n;
212	}
213#endif
214
215nocheck:
216	do
217		switch ((rv = read(fd, buf, n))) {
218		case -1:
219			if (errno == EINTR)
220				continue;
221			return -1;
222		case 0:
223			return rn - n;
224		default:
225			n -= rv;
226			buf = ((char *)buf) + rv;
227			break;
228		}
229	while (n > 0);
230	return rn;
231}
232
233protected int
234file_pipe2file(struct magic_set *ms, int fd, const void *startbuf,
235    size_t nbytes)
236{
237	char buf[4096];
238	int r, tfd;
239
240	(void)strlcpy(buf, "/tmp/file.XXXXXX", sizeof buf);
241#ifndef HAVE_MKSTEMP
242	{
243		char *ptr = mktemp(buf);
244		tfd = open(ptr, O_RDWR|O_TRUNC|O_EXCL|O_CREAT, 0600);
245		r = errno;
246		(void)unlink(ptr);
247		errno = r;
248	}
249#else
250	tfd = mkstemp(buf);
251	r = errno;
252	(void)unlink(buf);
253	errno = r;
254#endif
255	if (tfd == -1) {
256		file_error(ms, errno,
257		    "cannot create temporary file for pipe copy");
258		return -1;
259	}
260
261	if (swrite(tfd, startbuf, nbytes) != (ssize_t)nbytes)
262		r = 1;
263	else {
264		while ((r = sread(fd, buf, sizeof(buf), 1)) > 0)
265			if (swrite(tfd, buf, (size_t)r) != r)
266				break;
267	}
268
269	switch (r) {
270	case -1:
271		file_error(ms, errno, "error copying from pipe to temp file");
272		return -1;
273	case 0:
274		break;
275	default:
276		file_error(ms, errno, "error while writing to temp file");
277		return -1;
278	}
279
280	/*
281	 * We duplicate the file descriptor, because fclose on a
282	 * tmpfile will delete the file, but any open descriptors
283	 * can still access the phantom inode.
284	 */
285	if ((fd = dup2(tfd, fd)) == -1) {
286		file_error(ms, errno, "could not dup descriptor for temp file");
287		return -1;
288	}
289	(void)close(tfd);
290	if (lseek(fd, (off_t)0, SEEK_SET) == (off_t)-1) {
291		file_badseek(ms);
292		return -1;
293	}
294	return fd;
295}
296
297#ifdef BUILTIN_DECOMPRESS
298
299#define FHCRC		(1 << 1)
300#define FEXTRA		(1 << 2)
301#define FNAME		(1 << 3)
302#define FCOMMENT	(1 << 4)
303
304private size_t
305uncompressgzipped(struct magic_set *ms, const unsigned char *old,
306    unsigned char **newch, size_t n)
307{
308	unsigned char flg = old[3];
309	size_t data_start = 10;
310	z_stream z;
311	int rc;
312
313	if (flg & FEXTRA) {
314		if (data_start+1 >= n)
315			return 0;
316		data_start += 2 + old[data_start] + old[data_start + 1] * 256;
317	}
318	if (flg & FNAME) {
319		while(data_start < n && old[data_start])
320			data_start++;
321		data_start++;
322	}
323	if(flg & FCOMMENT) {
324		while(data_start < n && old[data_start])
325			data_start++;
326		data_start++;
327	}
328	if(flg & FHCRC)
329		data_start += 2;
330
331	if (data_start >= n)
332		return 0;
333	if ((*newch = CAST(unsigned char *, malloc(HOWMANY + 1))) == NULL) {
334		return 0;
335	}
336
337	/* XXX: const castaway, via strchr */
338	z.next_in = (Bytef *)strchr((const char *)old + data_start,
339	    old[data_start]);
340	z.avail_in = n - data_start;
341	z.next_out = *newch;
342	z.avail_out = HOWMANY;
343	z.zalloc = Z_NULL;
344	z.zfree = Z_NULL;
345	z.opaque = Z_NULL;
346
347	rc = inflateInit2(&z, -15);
348	if (rc != Z_OK) {
349		file_error(ms, 0, "zlib: %s", z.msg);
350		return 0;
351	}
352
353	rc = inflate(&z, Z_SYNC_FLUSH);
354	if (rc != Z_OK && rc != Z_STREAM_END) {
355		file_error(ms, 0, "zlib: %s", z.msg);
356		return 0;
357	}
358
359	n = (size_t)z.total_out;
360	(void)inflateEnd(&z);
361
362	/* let's keep the nul-terminate tradition */
363	(*newch)[n] = '\0';
364
365	return n;
366}
367#endif
368
369private size_t
370uncompressbuf(struct magic_set *ms, int fd, size_t method,
371    const unsigned char *old, unsigned char **newch, size_t n)
372{
373	int fdin[2], fdout[2];
374	int r;
375
376#ifdef BUILTIN_DECOMPRESS
377        /* FIXME: This doesn't cope with bzip2 */
378	if (method == 2)
379		return uncompressgzipped(ms, old, newch, n);
380#endif
381	(void)fflush(stdout);
382	(void)fflush(stderr);
383
384	if ((fd != -1 && pipe(fdin) == -1) || pipe(fdout) == -1) {
385		file_error(ms, errno, "cannot create pipe");
386		return NODATA;
387	}
388	switch (fork()) {
389	case 0:	/* child */
390		(void) close(0);
391		if (fd != -1) {
392		    (void) dup(fd);
393		    (void) lseek(0, (off_t)0, SEEK_SET);
394		} else {
395		    (void) dup(fdin[0]);
396		    (void) close(fdin[0]);
397		    (void) close(fdin[1]);
398		}
399
400		(void) close(1);
401		(void) dup(fdout[1]);
402		(void) close(fdout[0]);
403		(void) close(fdout[1]);
404#ifndef DEBUG
405		if (compr[method].silent)
406			(void)close(2);
407#endif
408
409		(void)execvp(compr[method].argv[0],
410		    (char *const *)(intptr_t)compr[method].argv);
411#ifdef DEBUG
412		(void)fprintf(stderr, "exec `%s' failed (%s)\n",
413		    compr[method].argv[0], strerror(errno));
414#endif
415		exit(1);
416		/*NOTREACHED*/
417	case -1:
418		file_error(ms, errno, "could not fork");
419		return NODATA;
420
421	default: /* parent */
422		(void) close(fdout[1]);
423		if (fd == -1) {
424			(void) close(fdin[0]);
425			/*
426			 * fork again, to avoid blocking because both
427			 * pipes filled
428			 */
429			switch (fork()) {
430			case 0: /* child */
431				(void)close(fdout[0]);
432				if (swrite(fdin[1], old, n) != (ssize_t)n) {
433#ifdef DEBUG
434					(void)fprintf(stderr,
435					    "Write failed (%s)\n",
436					    strerror(errno));
437#endif
438					exit(1);
439				}
440				exit(0);
441				/*NOTREACHED*/
442
443			case -1:
444#ifdef DEBUG
445				(void)fprintf(stderr, "Fork failed (%s)\n",
446				    strerror(errno));
447#endif
448				exit(1);
449				/*NOTREACHED*/
450
451			default:  /* parent */
452				break;
453			}
454			(void) close(fdin[1]);
455			fdin[1] = -1;
456		}
457
458		if ((*newch = (unsigned char *) malloc(HOWMANY + 1)) == NULL) {
459#ifdef DEBUG
460			(void)fprintf(stderr, "Malloc failed (%s)\n",
461			    strerror(errno));
462#endif
463			n = 0;
464			goto err;
465		}
466		if ((r = sread(fdout[0], *newch, HOWMANY, 0)) <= 0) {
467#ifdef DEBUG
468			(void)fprintf(stderr, "Read failed (%s)\n",
469			    strerror(errno));
470#endif
471			free(*newch);
472			n = 0;
473			newch[0] = '\0';
474			goto err;
475		} else {
476			n = r;
477		}
478 		/* NUL terminate, as every buffer is handled here. */
479 		(*newch)[n] = '\0';
480err:
481		if (fdin[1] != -1)
482			(void) close(fdin[1]);
483		(void) close(fdout[0]);
484#ifdef WNOHANG
485		while (waitpid(-1, NULL, WNOHANG) != -1)
486			continue;
487#else
488		(void)wait(NULL);
489#endif
490		(void) close(fdin[0]);
491
492		return n;
493	}
494}
495