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