Add unzip(1). If you can't beat 'em, join 'em
[dragonfly.git] / usr.bin / unzip / unzip.c
1 /*-
2  * Copyright (c) 2009, 2010 Joerg Sonnenberger <joerg@NetBSD.org>
3  * Copyright (c) 2007-2008 Dag-Erling Smørgrav
4  * All rights reserved.
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, this list of conditions and the following disclaimer
11  *    in this position and unchanged.
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
20  * FOR 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  * $FreeBSD: head/usr.bin/unzip/unzip.c 294108 2016-01-15 23:04:36Z ak $
29  *
30  * This file would be much shorter if we didn't care about command-line
31  * compatibility with Info-ZIP's UnZip, which requires us to duplicate
32  * parts of libarchive in order to gain more detailed control of its
33  * behaviour for the purpose of implementing the -n, -o, -L and -a
34  * options.
35  */
36
37 #include <sys/queue.h>
38 #include <sys/stat.h>
39
40 #include <ctype.h>
41 #include <errno.h>
42 #include <fcntl.h>
43 #include <fnmatch.h>
44 #include <stdarg.h>
45 #include <stdio.h>
46 #include <stdlib.h>
47 #include <string.h>
48 #include <unistd.h>
49
50 #include <archive.h>
51 #include <archive_entry.h>
52
53 /* command-line options */
54 static int               a_opt;         /* convert EOL */
55 static int               C_opt;         /* match case-insensitively */
56 static int               c_opt;         /* extract to stdout */
57 static const char       *d_arg;         /* directory */
58 static int               f_opt;         /* update existing files only */
59 static int               j_opt;         /* junk directories */
60 static int               L_opt;         /* lowercase names */
61 static int               n_opt;         /* never overwrite */
62 static int               o_opt;         /* always overwrite */
63 static int               p_opt;         /* extract to stdout, quiet */
64 static int               q_opt;         /* quiet */
65 static int               t_opt;         /* test */
66 static int               u_opt;         /* update */
67 static int               v_opt;         /* verbose/list */
68 static const char       *y_str = "";    /* 4 digit year */
69 static int               Z1_opt;        /* zipinfo mode list files only */
70
71 /* debug flag */
72 static int               unzip_debug;
73
74 /* zipinfo mode */
75 static int               zipinfo_mode;
76
77 /* running on tty? */
78 static int               tty;
79
80 /* convenience macro */
81 /* XXX should differentiate between ARCHIVE_{WARN,FAIL,RETRY} */
82 #define ac(call)                                                \
83         do {                                                    \
84                 int acret = (call);                             \
85                 if (acret != ARCHIVE_OK)                        \
86                         errorx("%s", archive_error_string(a));  \
87         } while (0)
88
89 /*
90  * Indicates that last info() did not end with EOL.  This helps error() et
91  * al. avoid printing an error message on the same line as an incomplete
92  * informational message.
93  */
94 static int noeol;
95
96 /* fatal error message + errno */
97 static void
98 error(const char *fmt, ...)
99 {
100         va_list ap;
101
102         if (noeol)
103                 fprintf(stdout, "\n");
104         fflush(stdout);
105         fprintf(stderr, "unzip: ");
106         va_start(ap, fmt);
107         vfprintf(stderr, fmt, ap);
108         va_end(ap);
109         fprintf(stderr, ": %s\n", strerror(errno));
110         exit(1);
111 }
112
113 /* fatal error message, no errno */
114 static void
115 errorx(const char *fmt, ...)
116 {
117         va_list ap;
118
119         if (noeol)
120                 fprintf(stdout, "\n");
121         fflush(stdout);
122         fprintf(stderr, "unzip: ");
123         va_start(ap, fmt);
124         vfprintf(stderr, fmt, ap);
125         va_end(ap);
126         fprintf(stderr, "\n");
127         exit(1);
128 }
129
130 /* non-fatal error message + errno */
131 static void
132 warning(const char *fmt, ...)
133 {
134         va_list ap;
135
136         if (noeol)
137                 fprintf(stdout, "\n");
138         fflush(stdout);
139         fprintf(stderr, "unzip: ");
140         va_start(ap, fmt);
141         vfprintf(stderr, fmt, ap);
142         va_end(ap);
143         fprintf(stderr, ": %s\n", strerror(errno));
144 }
145
146 /* non-fatal error message, no errno */
147 static void
148 warningx(const char *fmt, ...)
149 {
150         va_list ap;
151
152         if (noeol)
153                 fprintf(stdout, "\n");
154         fflush(stdout);
155         fprintf(stderr, "unzip: ");
156         va_start(ap, fmt);
157         vfprintf(stderr, fmt, ap);
158         va_end(ap);
159         fprintf(stderr, "\n");
160 }
161
162 /* informational message (if not -q) */
163 static void
164 info(const char *fmt, ...)
165 {
166         va_list ap;
167
168         if (q_opt && !unzip_debug)
169                 return;
170         va_start(ap, fmt);
171         vfprintf(stdout, fmt, ap);
172         va_end(ap);
173         fflush(stdout);
174
175         if (*fmt == '\0')
176                 noeol = 1;
177         else
178                 noeol = fmt[strlen(fmt) - 1] != '\n';
179 }
180
181 /* debug message (if unzip_debug) */
182 static void
183 debug(const char *fmt, ...)
184 {
185         va_list ap;
186
187         if (!unzip_debug)
188                 return;
189         va_start(ap, fmt);
190         vfprintf(stderr, fmt, ap);
191         va_end(ap);
192         fflush(stderr);
193
194         if (*fmt == '\0')
195                 noeol = 1;
196         else
197                 noeol = fmt[strlen(fmt) - 1] != '\n';
198 }
199
200 /* duplicate a path name, possibly converting to lower case */
201 static char *
202 pathdup(const char *path)
203 {
204         char *str;
205         size_t i, len;
206
207         len = strlen(path);
208         while (len && path[len - 1] == '/')
209                 len--;
210         if ((str = malloc(len + 1)) == NULL) {
211                 errno = ENOMEM;
212                 error("malloc()");
213         }
214         if (L_opt) {
215                 for (i = 0; i < len; ++i)
216                         str[i] = tolower((unsigned char)path[i]);
217         } else {
218                 memcpy(str, path, len);
219         }
220         str[len] = '\0';
221
222         return (str);
223 }
224
225 /* concatenate two path names */
226 static char *
227 pathcat(const char *prefix, const char *path)
228 {
229         char *str;
230         size_t prelen, len;
231
232         prelen = prefix ? strlen(prefix) + 1 : 0;
233         len = strlen(path) + 1;
234         if ((str = malloc(prelen + len)) == NULL) {
235                 errno = ENOMEM;
236                 error("malloc()");
237         }
238         if (prefix) {
239                 memcpy(str, prefix, prelen);    /* includes zero */
240                 str[prelen - 1] = '/';          /* splat zero */
241         }
242         memcpy(str + prelen, path, len);        /* includes zero */
243
244         return (str);
245 }
246
247 /*
248  * Pattern lists for include / exclude processing
249  */
250 struct pattern {
251         STAILQ_ENTRY(pattern) link;
252         char pattern[];
253 };
254
255 STAILQ_HEAD(pattern_list, pattern);
256 static struct pattern_list include = STAILQ_HEAD_INITIALIZER(include);
257 static struct pattern_list exclude = STAILQ_HEAD_INITIALIZER(exclude);
258
259 /*
260  * Add an entry to a pattern list
261  */
262 static void
263 add_pattern(struct pattern_list *list, const char *pattern)
264 {
265         struct pattern *entry;
266         size_t len;
267
268         debug("adding pattern '%s'\n", pattern);
269         len = strlen(pattern);
270         if ((entry = malloc(sizeof *entry + len + 1)) == NULL) {
271                 errno = ENOMEM;
272                 error("malloc()");
273         }
274         memcpy(entry->pattern, pattern, len + 1);
275         STAILQ_INSERT_TAIL(list, entry, link);
276 }
277
278 /*
279  * Match a string against a list of patterns
280  */
281 static int
282 match_pattern(struct pattern_list *list, const char *str)
283 {
284         struct pattern *entry;
285
286         STAILQ_FOREACH(entry, list, link) {
287                 if (fnmatch(entry->pattern, str, C_opt ? FNM_CASEFOLD : 0) == 0)
288                         return (1);
289         }
290         return (0);
291 }
292
293 /*
294  * Verify that a given pathname is in the include list and not in the
295  * exclude list.
296  */
297 static int
298 accept_pathname(const char *pathname)
299 {
300
301         if (!STAILQ_EMPTY(&include) && !match_pattern(&include, pathname))
302                 return (0);
303         if (!STAILQ_EMPTY(&exclude) && match_pattern(&exclude, pathname))
304                 return (0);
305         return (1);
306 }
307
308 /*
309  * Create the specified directory with the specified mode, taking certain
310  * precautions on they way.
311  */
312 static void
313 make_dir(const char *path, int mode)
314 {
315         struct stat sb;
316
317         if (lstat(path, &sb) == 0) {
318                 if (S_ISDIR(sb.st_mode))
319                         return;
320                 /*
321                  * Normally, we should either ask the user about removing
322                  * the non-directory of the same name as a directory we
323                  * wish to create, or respect the -n or -o command-line
324                  * options.  However, this may lead to a later failure or
325                  * even compromise (if this non-directory happens to be a
326                  * symlink to somewhere unsafe), so we don't.
327                  */
328
329                 /*
330                  * Don't check unlink() result; failure will cause mkdir()
331                  * to fail later, which we will catch.
332                  */
333                 (void)unlink(path);
334         }
335         if (mkdir(path, mode) != 0 && errno != EEXIST)
336                 error("mkdir('%s')", path);
337 }
338
339 /*
340  * Ensure that all directories leading up to (but not including) the
341  * specified path exist.
342  *
343  * XXX inefficient + modifies the file in-place
344  */
345 static void
346 make_parent(char *path)
347 {
348         struct stat sb;
349         char *sep;
350
351         sep = strrchr(path, '/');
352         if (sep == NULL || sep == path)
353                 return;
354         *sep = '\0';
355         if (lstat(path, &sb) == 0) {
356                 if (S_ISDIR(sb.st_mode)) {
357                         *sep = '/';
358                         return;
359                 }
360                 unlink(path);
361         }
362         make_parent(path);
363         mkdir(path, 0755);
364         *sep = '/';
365
366 #if 0
367         for (sep = path; (sep = strchr(sep, '/')) != NULL; sep++) {
368                 /* root in case of absolute d_arg */
369                 if (sep == path)
370                         continue;
371                 *sep = '\0';
372                 make_dir(path, 0755);
373                 *sep = '/';
374         }
375 #endif
376 }
377
378 /*
379  * Extract a directory.
380  */
381 static void
382 extract_dir(struct archive *a, struct archive_entry *e, const char *path)
383 {
384         int mode;
385
386         mode = archive_entry_mode(e) & 0777;
387         if (mode == 0)
388                 mode = 0755;
389
390         /*
391          * Some zipfiles contain directories with weird permissions such
392          * as 0644 or 0444.  This can cause strange issues such as being
393          * unable to extract files into the directory we just created, or
394          * the user being unable to remove the directory later without
395          * first manually changing its permissions.  Therefore, we whack
396          * the permissions into shape, assuming that the user wants full
397          * access and that anyone who gets read access also gets execute
398          * access.
399          */
400         mode |= 0700;
401         if (mode & 0040)
402                 mode |= 0010;
403         if (mode & 0004)
404                 mode |= 0001;
405
406         info("   creating: %s/\n", path);
407         make_dir(path, mode);
408         ac(archive_read_data_skip(a));
409 }
410
411 static unsigned char buffer[8192];
412 static char spinner[] = { '|', '/', '-', '\\' };
413
414 static int
415 handle_existing_file(char **path)
416 {
417         size_t alen;
418         ssize_t len;
419         char buf[4];
420
421         for (;;) {
422                 fprintf(stderr,
423                     "replace %s? [y]es, [n]o, [A]ll, [N]one, [r]ename: ",
424                     *path);
425                 if (fgets(buf, sizeof(buf), stdin) == NULL) {
426                         clearerr(stdin);
427                         printf("NULL\n(EOF or read error, "
428                             "treating as \"[N]one\"...)\n");
429                         n_opt = 1;
430                         return -1;
431                 }
432                 switch (*buf) {
433                 case 'A':
434                         o_opt = 1;
435                         /* FALLTHROUGH */
436                 case 'y':
437                 case 'Y':
438                         (void)unlink(*path);
439                         return 1;
440                 case 'N':
441                         n_opt = 1;
442                         /* FALLTHROUGH */
443                 case 'n':
444                         return -1;
445                 case 'r':
446                 case 'R':
447                         printf("New name: ");
448                         fflush(stdout);
449                         free(*path);
450                         *path = NULL;
451                         alen = 0;
452                         len = getdelim(path, &alen, '\n', stdin);
453                         if ((*path)[len - 1] == '\n')
454                                 (*path)[len - 1] = '\0';
455                         return 0;
456                 default:
457                         break;
458                 }
459         }
460 }
461
462 /*
463  * Detect binary files by a combination of character white list and
464  * black list. NUL bytes and other control codes without use in text files
465  * result directly in switching the file to binary mode. Otherwise, at least
466  * one white-listed byte has to be found.
467  *
468  * Black-listed: 0..6, 14..25, 28..31
469  * 0xf3ffc07f = 11110011111111111100000001111111b
470  * White-listed: 9..10, 13, >= 32
471  * 0x00002600 = 00000000000000000010011000000000b
472  *
473  * See the proginfo/txtvsbin.txt in the zip sources for a detailed discussion.
474  */
475 #define BYTE_IS_BINARY(x)       ((x) < 32 && (0xf3ffc07fU & (1U << (x))))
476 #define BYTE_IS_TEXT(x)         ((x) >= 32 || (0x00002600U & (1U << (x))))
477
478 static int
479 check_binary(const unsigned char *buf, size_t len)
480 {
481         int rv;
482         for (rv = 1; len--; ++buf) {
483                 if (BYTE_IS_BINARY(*buf))
484                         return 1;
485                 if (BYTE_IS_TEXT(*buf))
486                         rv = 0;
487         }
488
489         return rv;
490 }
491
492 /*
493  * Extract to a file descriptor
494  */
495 static int
496 extract2fd(struct archive *a, char *pathname, int fd)
497 {
498         int cr, text, warn;
499         ssize_t len;
500         unsigned char *p, *q, *end;
501
502         text = a_opt;
503         warn = 0;
504         cr = 0;
505
506         /* loop over file contents and write to fd */
507         for (int n = 0; ; n++) {
508                 if (fd != STDOUT_FILENO)
509                         if (tty && (n % 4) == 0)
510                                 info(" %c\b\b", spinner[(n / 4) % sizeof spinner]);
511
512                 len = archive_read_data(a, buffer, sizeof buffer);
513
514                 if (len < 0)
515                         ac(len);
516
517                 /* left over CR from previous buffer */
518                 if (a_opt && cr) {
519                         if (len == 0 || buffer[0] != '\n')
520                                 if (write(fd, "\r", 1) != 1)
521                                         error("write('%s')", pathname);
522                         cr = 0;
523                 }
524
525                 /* EOF */
526                 if (len == 0)
527                         break;
528                 end = buffer + len;
529
530                 /*
531                  * Detect whether this is a text file.  The correct way to
532                  * do this is to check the least significant bit of the
533                  * "internal file attributes" field of the corresponding
534                  * file header in the central directory, but libarchive
535                  * does not provide access to this field, so we have to
536                  * guess by looking for non-ASCII characters in the
537                  * buffer.  Hopefully we won't guess wrong.  If we do
538                  * guess wrong, we print a warning message later.
539                  */
540                 if (a_opt && n == 0) {
541                         if (check_binary(buffer, len))
542                                 text = 0;
543                 }
544
545                 /* simple case */
546                 if (!a_opt || !text) {
547                         if (write(fd, buffer, len) != len)
548                                 error("write('%s')", pathname);
549                         continue;
550                 }
551
552                 /* hard case: convert \r\n to \n (sigh...) */
553                 for (p = buffer; p < end; p = q + 1) {
554                         for (q = p; q < end; q++) {
555                                 if (!warn && BYTE_IS_BINARY(*q)) {
556                                         warningx("%s may be corrupted due"
557                                             " to weak text file detection"
558                                             " heuristic", pathname);
559                                         warn = 1;
560                                 }
561                                 if (q[0] != '\r')
562                                         continue;
563                                 if (&q[1] == end) {
564                                         cr = 1;
565                                         break;
566                                 }
567                                 if (q[1] == '\n')
568                                         break;
569                         }
570                         if (write(fd, p, q - p) != q - p)
571                                 error("write('%s')", pathname);
572                 }
573         }
574
575         return text;
576 }
577
578 /*
579  * Extract a regular file.
580  */
581 static void
582 extract_file(struct archive *a, struct archive_entry *e, char **path)
583 {
584         int mode;
585         struct timespec mtime;
586         struct stat sb;
587         struct timespec ts[2];
588         int fd, check, text;
589         const char *linkname;
590
591         mode = archive_entry_mode(e) & 0777;
592         if (mode == 0)
593                 mode = 0644;
594         mtime.tv_sec = archive_entry_mtime(e);
595         mtime.tv_nsec = archive_entry_mtime_nsec(e);
596
597         /* look for existing file of same name */
598 recheck:
599         if (lstat(*path, &sb) == 0) {
600                 if (u_opt || f_opt) {
601                         /* check if up-to-date */
602                         if ((S_ISREG(sb.st_mode) || S_ISLNK(sb.st_mode)) &&
603                             (sb.st_mtim.tv_sec > mtime.tv_sec ||
604                             (sb.st_mtim.tv_sec == mtime.tv_sec &&
605                             sb.st_mtim.tv_nsec >= mtime.tv_nsec)))
606                                 return;
607                         (void)unlink(*path);
608                 } else if (o_opt) {
609                         /* overwrite */
610                         (void)unlink(*path);
611                 } else if (n_opt) {
612                         /* do not overwrite */
613                         return;
614                 } else {
615                         check = handle_existing_file(path);
616                         if (check == 0)
617                                 goto recheck;
618                         if (check == -1)
619                                 return; /* do not overwrite */
620                 }
621         } else {
622                 if (f_opt)
623                         return;
624         }
625
626         ts[0].tv_sec = 0;
627         ts[0].tv_nsec = UTIME_NOW;
628         ts[1] = mtime;
629
630         /* process symlinks */
631         linkname = archive_entry_symlink(e);
632         if (linkname != NULL) {
633                 if (symlink(linkname, *path) != 0)
634                         error("symlink('%s')", *path);
635                 info(" extracting: %s -> %s\n", *path, linkname);
636                 if (lchmod(*path, mode) != 0)
637                         warning("Cannot set mode for '%s'", *path);
638                 /* set access and modification time */
639                 if (utimensat(AT_FDCWD, *path, ts, AT_SYMLINK_NOFOLLOW) != 0)
640                         warning("utimensat('%s')", *path);
641                 return;
642         }
643
644         if ((fd = open(*path, O_RDWR|O_CREAT|O_TRUNC, mode)) < 0)
645                 error("open('%s')", *path);
646
647         info(" extracting: %s", *path);
648
649         text = extract2fd(a, *path, fd);
650
651         if (tty)
652                 info("  \b\b");
653         if (text)
654                 info(" (text)");
655         info("\n");
656
657         /* set access and modification time */
658         if (futimens(fd, ts) != 0)
659                 error("futimens('%s')", *path);
660         if (close(fd) != 0)
661                 error("close('%s')", *path);
662 }
663
664 /*
665  * Extract a zipfile entry: first perform some sanity checks to ensure
666  * that it is either a directory or a regular file and that the path is
667  * not absolute and does not try to break out of the current directory;
668  * then call either extract_dir() or extract_file() as appropriate.
669  *
670  * This is complicated a bit by the various ways in which we need to
671  * manipulate the path name.  Case conversion (if requested by the -L
672  * option) happens first, but the include / exclude patterns are applied
673  * to the full converted path name, before the directory part of the path
674  * is removed in accordance with the -j option.  Sanity checks are
675  * intentionally done earlier than they need to be, so the user will get a
676  * warning about insecure paths even for files or directories which
677  * wouldn't be extracted anyway.
678  */
679 static void
680 extract(struct archive *a, struct archive_entry *e)
681 {
682         char *pathname, *realpathname;
683         mode_t filetype;
684         char *p, *q;
685
686         pathname = pathdup(archive_entry_pathname(e));
687         filetype = archive_entry_filetype(e);
688
689         /* sanity checks */
690         if (pathname[0] == '/' ||
691             strncmp(pathname, "../", 3) == 0 ||
692             strstr(pathname, "/../") != NULL) {
693                 warningx("skipping insecure entry '%s'", pathname);
694                 ac(archive_read_data_skip(a));
695                 free(pathname);
696                 return;
697         }
698
699         /* I don't think this can happen in a zipfile.. */
700         if (!S_ISDIR(filetype) && !S_ISREG(filetype) && !S_ISLNK(filetype)) {
701                 warningx("skipping non-regular entry '%s'", pathname);
702                 ac(archive_read_data_skip(a));
703                 free(pathname);
704                 return;
705         }
706
707         /* skip directories in -j case */
708         if (S_ISDIR(filetype) && j_opt) {
709                 ac(archive_read_data_skip(a));
710                 free(pathname);
711                 return;
712         }
713
714         /* apply include / exclude patterns */
715         if (!accept_pathname(pathname)) {
716                 ac(archive_read_data_skip(a));
717                 free(pathname);
718                 return;
719         }
720
721         /* apply -j and -d */
722         if (j_opt) {
723                 for (p = q = pathname; *p; ++p)
724                         if (*p == '/')
725                                 q = p + 1;
726                 realpathname = pathcat(d_arg, q);
727         } else {
728                 realpathname = pathcat(d_arg, pathname);
729         }
730
731         /* ensure that parent directory exists */
732         make_parent(realpathname);
733
734         if (S_ISDIR(filetype))
735                 extract_dir(a, e, realpathname);
736         else
737                 extract_file(a, e, &realpathname);
738
739         free(realpathname);
740         free(pathname);
741 }
742
743 static void
744 extract_stdout(struct archive *a, struct archive_entry *e)
745 {
746         char *pathname;
747         mode_t filetype;
748
749         pathname = pathdup(archive_entry_pathname(e));
750         filetype = archive_entry_filetype(e);
751
752         /* I don't think this can happen in a zipfile.. */
753         if (!S_ISDIR(filetype) && !S_ISREG(filetype) && !S_ISLNK(filetype)) {
754                 warningx("skipping non-regular entry '%s'", pathname);
755                 ac(archive_read_data_skip(a));
756                 free(pathname);
757                 return;
758         }
759
760         /* skip directories in -j case */
761         if (S_ISDIR(filetype)) {
762                 ac(archive_read_data_skip(a));
763                 free(pathname);
764                 return;
765         }
766
767         /* apply include / exclude patterns */
768         if (!accept_pathname(pathname)) {
769                 ac(archive_read_data_skip(a));
770                 free(pathname);
771                 return;
772         }
773
774         if (c_opt)
775                 info("x %s\n", pathname);
776
777         (void)extract2fd(a, pathname, STDOUT_FILENO);
778
779         free(pathname);
780 }
781
782 /*
783  * Print the name of an entry to stdout.
784  */
785 static void
786 list(struct archive *a, struct archive_entry *e)
787 {
788         char buf[20];
789         time_t mtime;
790         struct tm *tm;
791
792         mtime = archive_entry_mtime(e);
793         tm = localtime(&mtime);
794         if (*y_str)
795                 strftime(buf, sizeof(buf), "%m-%d-%G %R", tm);
796         else
797                 strftime(buf, sizeof(buf), "%m-%d-%g %R", tm);
798
799         if (!zipinfo_mode) {
800                 if (v_opt == 1) {
801                         printf(" %8ju  %s   %s\n",
802                             (uintmax_t)archive_entry_size(e),
803                             buf, archive_entry_pathname(e));
804                 } else if (v_opt == 2) {
805                         printf("%8ju  Stored  %7ju   0%%  %s  %08x  %s\n",
806                             (uintmax_t)archive_entry_size(e),
807                             (uintmax_t)archive_entry_size(e),
808                             buf,
809                             0U,
810                             archive_entry_pathname(e));
811                 }
812         } else {
813                 if (Z1_opt)
814                         printf("%s\n",archive_entry_pathname(e));
815         }
816         ac(archive_read_data_skip(a));
817 }
818
819 /*
820  * Extract to memory to check CRC
821  */
822 static int
823 test(struct archive *a, struct archive_entry *e)
824 {
825         ssize_t len;
826         int error_count;
827
828         error_count = 0;
829         if (S_ISDIR(archive_entry_filetype(e)))
830                 return 0;
831
832         info("    testing: %s\t", archive_entry_pathname(e));
833         while ((len = archive_read_data(a, buffer, sizeof buffer)) > 0)
834                 /* nothing */;
835         if (len < 0) {
836                 info(" %s\n", archive_error_string(a));
837                 ++error_count;
838         } else {
839                 info(" OK\n");
840         }
841
842         /* shouldn't be necessary, but it doesn't hurt */
843         ac(archive_read_data_skip(a));
844
845         return error_count;
846 }
847
848 /*
849  * Main loop: open the zipfile, iterate over its contents and decide what
850  * to do with each entry.
851  */
852 static void
853 unzip(const char *fn)
854 {
855         struct archive *a;
856         struct archive_entry *e;
857         int ret;
858         uintmax_t total_size, file_count, error_count;
859
860         if ((a = archive_read_new()) == NULL)
861                 error("archive_read_new failed");
862
863         ac(archive_read_support_format_zip(a));
864         ac(archive_read_open_filename(a, fn, 8192));
865
866         if (!zipinfo_mode) {
867                 if (!p_opt && !q_opt)
868                         printf("Archive:  %s\n", fn);
869                 if (v_opt == 1) {
870                         printf("  Length     %sDate   Time    Name\n", y_str);
871                         printf(" --------    %s----   ----    ----\n", y_str);
872                 } else if (v_opt == 2) {
873                         printf(" Length   Method    Size  Ratio   %sDate   Time   CRC-32    Name\n", y_str);
874                         printf("--------  ------  ------- -----   %s----   ----   ------    ----\n", y_str);
875                 }
876         }
877
878         total_size = 0;
879         file_count = 0;
880         error_count = 0;
881         for (;;) {
882                 ret = archive_read_next_header(a, &e);
883                 if (ret == ARCHIVE_EOF)
884                         break;
885                 ac(ret);
886                 if (!zipinfo_mode) {
887                         if (t_opt)
888                                 error_count += test(a, e);
889                         else if (v_opt)
890                                 list(a, e);
891                         else if (p_opt || c_opt)
892                                 extract_stdout(a, e);
893                         else
894                                 extract(a, e);
895                 } else {
896                         if (Z1_opt)
897                                 list(a, e);
898                 }
899
900                 total_size += archive_entry_size(e);
901                 ++file_count;
902         }
903
904         if (zipinfo_mode) {
905                 if (v_opt == 1) {
906                         printf(" --------                   %s-------\n", y_str);
907                         printf(" %8ju                   %s%ju file%s\n",
908                             total_size, y_str, file_count, file_count != 1 ? "s" : "");
909                 } else if (v_opt == 2) {
910                         printf("--------          -------  ---                            %s-------\n", y_str);
911                         printf("%8ju          %7ju   0%%                            %s%ju file%s\n",
912                             total_size, total_size, y_str, file_count,
913                             file_count != 1 ? "s" : "");
914                 }
915         }
916
917         ac(archive_read_close(a));
918         (void)archive_read_free(a);
919
920         if (t_opt) {
921                 if (error_count > 0) {
922                         errorx("%ju checksum error(s) found.", error_count);
923                 }
924                 else {
925                         printf("No errors detected in compressed data of %s.\n",
926                                fn);
927                 }
928         }
929 }
930
931 static void
932 usage(void)
933 {
934
935         fprintf(stderr, "Usage: unzip [-aCcfjLlnopqtuvyZ1] [-d dir] [-x pattern] "
936                 "zipfile\n");
937         exit(1);
938 }
939
940 static int
941 getopts(int argc, char *argv[])
942 {
943         int opt;
944
945         optreset = optind = 1;
946         while ((opt = getopt(argc, argv, "aCcd:fjLlnopqtuvx:yZ1")) != -1)
947                 switch (opt) {
948                 case '1':
949                         Z1_opt = 1;
950                         break;
951                 case 'a':
952                         a_opt = 1;
953                         break;
954                 case 'C':
955                         C_opt = 1;
956                         break;
957                 case 'c':
958                         c_opt = 1;
959                         break;
960                 case 'd':
961                         d_arg = optarg;
962                         break;
963                 case 'f':
964                         f_opt = 1;
965                         break;
966                 case 'j':
967                         j_opt = 1;
968                         break;
969                 case 'L':
970                         L_opt = 1;
971                         break;
972                 case 'l':
973                         if (v_opt == 0)
974                                 v_opt = 1;
975                         break;
976                 case 'n':
977                         n_opt = 1;
978                         break;
979                 case 'o':
980                         o_opt = 1;
981                         q_opt = 1;
982                         break;
983                 case 'p':
984                         p_opt = 1;
985                         break;
986                 case 'q':
987                         q_opt = 1;
988                         break;
989                 case 't':
990                         t_opt = 1;
991                         break;
992                 case 'u':
993                         u_opt = 1;
994                         break;
995                 case 'v':
996                         v_opt = 2;
997                         break;
998                 case 'x':
999                         add_pattern(&exclude, optarg);
1000                         break;
1001                 case 'y':
1002                         y_str = "  ";
1003                         break;
1004                 case 'Z':
1005                         zipinfo_mode = 1;
1006                         break;
1007                 default:
1008                         usage();
1009                 }
1010
1011         return (optind);
1012 }
1013
1014 int
1015 main(int argc, char *argv[])
1016 {
1017         const char *zipfile;
1018         int nopts;
1019
1020         if (isatty(STDOUT_FILENO))
1021                 tty = 1;
1022
1023         if (getenv("UNZIP_DEBUG") != NULL)
1024                 unzip_debug = 1;
1025         for (int i = 0; i < argc; ++i)
1026                 debug("%s%c", argv[i], (i < argc - 1) ? ' ' : '\n');
1027
1028         /*
1029          * Info-ZIP's unzip(1) expects certain options to come before the
1030          * zipfile name, and others to come after - though it does not
1031          * enforce this.  For simplicity, we accept *all* options both
1032          * before and after the zipfile name.
1033          */
1034         nopts = getopts(argc, argv);
1035
1036         /*
1037          * When more of the zipinfo mode options are implemented, this
1038          * will need to change.
1039          */
1040         if (zipinfo_mode && !Z1_opt) {
1041                 printf("Zipinfo mode needs additional options\n");
1042                 exit(1);
1043         }
1044
1045         if (argc <= nopts)
1046                 usage();
1047         zipfile = argv[nopts++];
1048
1049         if (strcmp(zipfile, "-") == 0)
1050                 zipfile = NULL; /* STDIN */
1051
1052         while (nopts < argc && *argv[nopts] != '-')
1053                 add_pattern(&include, argv[nopts++]);
1054
1055         nopts--; /* fake argv[0] */
1056         nopts += getopts(argc - nopts, argv + nopts);
1057
1058         if (n_opt + o_opt + u_opt > 1)
1059                 errorx("-n, -o and -u are contradictory");
1060
1061         unzip(zipfile);
1062
1063         exit(0);
1064 }