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