unzip.c revision 302408 
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: stable/11/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 */
54static int		 a_opt;		/* convert EOL */
55static int		 C_opt;		/* match case-insensitively */
56static int		 c_opt;		/* extract to stdout */
57static const char	*d_arg;		/* directory */
58static int		 f_opt;		/* update existing files only */
59static int		 j_opt;		/* junk directories */
60static int		 L_opt;		/* lowercase names */
61static int		 n_opt;		/* never overwrite */
62static int		 o_opt;		/* always overwrite */
63static int		 p_opt;		/* extract to stdout, quiet */
64static int		 q_opt;		/* quiet */
65static int		 t_opt;		/* test */
66static int		 u_opt;		/* update */
67static int		 v_opt;		/* verbose/list */
68static const char	*y_str = "";	/* 4 digit year */
69static int		 Z1_opt;	/* zipinfo mode list files only */
70
71/* debug flag */
72static int		 unzip_debug;
73
74/* zipinfo mode */
75static int		 zipinfo_mode;
76
77/* running on tty? */
78static 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 */
94static int noeol;
95
96/* fatal error message + errno */
97static void
98error(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 */
114static void
115errorx(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 */
131static void
132warning(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 */
147static void
148warningx(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) */
163static void
164info(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) */
182static void
183debug(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 */
201static char *
202pathdup(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 */
226static char *
227pathcat(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 */
250struct pattern {
251	STAILQ_ENTRY(pattern) link;
252	char pattern[];
253};
254
255STAILQ_HEAD(pattern_list, pattern);
256static struct pattern_list include = STAILQ_HEAD_INITIALIZER(include);
257static struct pattern_list exclude = STAILQ_HEAD_INITIALIZER(exclude);
258
259/*
260 * Add an entry to a pattern list
261 */
262static void
263add_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 */
281static int
282match_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 */
297static int
298accept_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 */
312static void
313make_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 */
345static void
346make_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 */
381static void
382extract_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
411static unsigned char buffer[8192];
412static char spinner[] = { '|', '/', '-', '\\' };
413
414static int
415handle_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
478static int
479check_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 */
495static int
496extract2fd(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 */
581static void
582extract_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 */
598recheck:
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 */
679static void
680extract(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
743static void
744extract_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 */
785static void
786list(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 */
822static int
823test(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 */
852static void
853unzip(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
931static void
932usage(void)
933{
934
935	fprintf(stderr, "Usage: unzip [-aCcfjLlnopqtuvyZ1] [-d dir] [-x pattern] "
936		"zipfile\n");
937	exit(1);
938}
939
940static int
941getopts(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
1014int
1015main(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}
1065