1 /*
2 * Copyright (c) 1995, 2017, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package java.util.zip;
27
28 import java.io.Closeable;
29 import java.io.InputStream;
30 import java.io.IOException;
31 import java.io.EOFException;
32 import java.io.File;
33 import java.io.RandomAccessFile;
34 import java.nio.charset.Charset;
35 import java.nio.charset.StandardCharsets;
36 import java.nio.file.attribute.BasicFileAttributes;
37 import java.nio.file.Path;
38 import java.nio.file.Files;
39
40 import java.util.ArrayDeque;
41 import java.util.ArrayList;
42 import java.util.Arrays;
43 import java.util.Deque;
44 import java.util.Enumeration;
45 import java.util.HashMap;
46 import java.util.Iterator;
47 import java.util.Map;
48 import java.util.Objects;
49 import java.util.NoSuchElementException;
50 import java.util.Spliterator;
51 import java.util.Spliterators;
52 import java.util.WeakHashMap;
53 import java.util.stream.Stream;
54 import java.util.stream.StreamSupport;
55 import jdk.internal.misc.JavaUtilZipFileAccess;
56 import jdk.internal.misc.SharedSecrets;
57 import jdk.internal.misc.JavaIORandomAccessFileAccess;
58 import jdk.internal.misc.VM;
59 import jdk.internal.perf.PerfCounter;
60
61 import static java.util.zip.ZipConstants.*;
62 import static java.util.zip.ZipConstants64.*;
63 import static java.util.zip.ZipUtils.*;
64
65 /**
66 * This class is used to read entries from a zip file.
67 *
68 * <p> Unless otherwise noted, passing a {@code null} argument to a constructor
69 * or method in this class will cause a {@link NullPointerException} to be
70 * thrown.
71 *
72 * @author David Connelly
73 * @since 1.1
74 */
75 public
76 class ZipFile implements ZipConstants, Closeable {
77
78 private final String name; // zip file name
79 private volatile boolean closeRequested;
80 private Source zsrc;
81 private ZipCoder zc;
82
83 private static final int STORED = ZipEntry.STORED;
84 private static final int DEFLATED = ZipEntry.DEFLATED;
85
86 /**
87 * Mode flag to open a zip file for reading.
88 */
89 public static final int OPEN_READ = 0x1;
90
91 /**
92 * Mode flag to open a zip file and mark it for deletion. The file will be
93 * deleted some time between the moment that it is opened and the moment
94 * that it is closed, but its contents will remain accessible via the
95 * {@code ZipFile} object until either the close method is invoked or the
96 * virtual machine exits.
97 */
98 public static final int OPEN_DELETE = 0x4;
99
100 /**
101 * Opens a zip file for reading.
102 *
103 * <p>First, if there is a security manager, its {@code checkRead}
104 * method is called with the {@code name} argument as its argument
105 * to ensure the read is allowed.
106 *
107 * <p>The UTF-8 {@link java.nio.charset.Charset charset} is used to
108 * decode the entry names and comments.
109 *
110 * @param name the name of the zip file
111 * @throws ZipException if a ZIP format error has occurred
112 * @throws IOException if an I/O error has occurred
113 * @throws SecurityException if a security manager exists and its
114 * {@code checkRead} method doesn't allow read access to the file.
115 *
116 * @see SecurityManager#checkRead(java.lang.String)
117 */
118 public ZipFile(String name) throws IOException {
119 this(new File(name), OPEN_READ);
120 }
121
122 /**
123 * Opens a new {@code ZipFile} to read from the specified
124 * {@code File} object in the specified mode. The mode argument
125 * must be either {@code OPEN_READ} or {@code OPEN_READ | OPEN_DELETE}.
126 *
127 * <p>First, if there is a security manager, its {@code checkRead}
128 * method is called with the {@code name} argument as its argument to
129 * ensure the read is allowed.
130 *
131 * <p>The UTF-8 {@link java.nio.charset.Charset charset} is used to
132 * decode the entry names and comments
133 *
134 * @param file the ZIP file to be opened for reading
135 * @param mode the mode in which the file is to be opened
136 * @throws ZipException if a ZIP format error has occurred
137 * @throws IOException if an I/O error has occurred
138 * @throws SecurityException if a security manager exists and
139 * its {@code checkRead} method
140 * doesn't allow read access to the file,
141 * or its {@code checkDelete} method doesn't allow deleting
142 * the file when the {@code OPEN_DELETE} flag is set.
143 * @throws IllegalArgumentException if the {@code mode} argument is invalid
144 * @see SecurityManager#checkRead(java.lang.String)
145 * @since 1.3
146 */
147 public ZipFile(File file, int mode) throws IOException {
148 this(file, mode, StandardCharsets.UTF_8);
149 }
150
151 /**
152 * Opens a ZIP file for reading given the specified File object.
153 *
154 * <p>The UTF-8 {@link java.nio.charset.Charset charset} is used to
155 * decode the entry names and comments.
156 *
157 * @param file the ZIP file to be opened for reading
158 * @throws ZipException if a ZIP format error has occurred
159 * @throws IOException if an I/O error has occurred
160 */
161 public ZipFile(File file) throws ZipException, IOException {
162 this(file, OPEN_READ);
163 }
164
165 /**
166 * Opens a new {@code ZipFile} to read from the specified
167 * {@code File} object in the specified mode. The mode argument
168 * must be either {@code OPEN_READ} or {@code OPEN_READ | OPEN_DELETE}.
169 *
170 * <p>First, if there is a security manager, its {@code checkRead}
171 * method is called with the {@code name} argument as its argument to
172 * ensure the read is allowed.
173 *
174 * @param file the ZIP file to be opened for reading
175 * @param mode the mode in which the file is to be opened
176 * @param charset
177 * the {@linkplain java.nio.charset.Charset charset} to
178 * be used to decode the ZIP entry name and comment that are not
179 * encoded by using UTF-8 encoding (indicated by entry's general
180 * purpose flag).
181 *
182 * @throws ZipException if a ZIP format error has occurred
183 * @throws IOException if an I/O error has occurred
184 *
185 * @throws SecurityException
186 * if a security manager exists and its {@code checkRead}
187 * method doesn't allow read access to the file,or its
188 * {@code checkDelete} method doesn't allow deleting the
189 * file when the {@code OPEN_DELETE} flag is set
190 *
191 * @throws IllegalArgumentException if the {@code mode} argument is invalid
192 *
193 * @see SecurityManager#checkRead(java.lang.String)
194 *
195 * @since 1.7
196 */
197 public ZipFile(File file, int mode, Charset charset) throws IOException
198 {
199 if (((mode & OPEN_READ) == 0) ||
200 ((mode & ~(OPEN_READ | OPEN_DELETE)) != 0)) {
201 throw new IllegalArgumentException("Illegal mode: 0x"+
202 Integer.toHexString(mode));
203 }
204 String name = file.getPath();
205 SecurityManager sm = System.getSecurityManager();
206 if (sm != null) {
207 sm.checkRead(name);
208 if ((mode & OPEN_DELETE) != 0) {
209 sm.checkDelete(name);
210 }
211 }
212 Objects.requireNonNull(charset, "charset");
213 this.zc = ZipCoder.get(charset);
214 this.name = name;
215 long t0 = System.nanoTime();
216 this.zsrc = Source.get(file, (mode & OPEN_DELETE) != 0);
217 PerfCounter.getZipFileOpenTime().addElapsedTimeFrom(t0);
218 PerfCounter.getZipFileCount().increment();
219 }
220
221 /**
222 * Opens a zip file for reading.
223 *
224 * <p>First, if there is a security manager, its {@code checkRead}
225 * method is called with the {@code name} argument as its argument
226 * to ensure the read is allowed.
227 *
228 * @param name the name of the zip file
229 * @param charset
230 * the {@linkplain java.nio.charset.Charset charset} to
231 * be used to decode the ZIP entry name and comment that are not
232 * encoded by using UTF-8 encoding (indicated by entry's general
233 * purpose flag).
234 *
235 * @throws ZipException if a ZIP format error has occurred
236 * @throws IOException if an I/O error has occurred
237 * @throws SecurityException
238 * if a security manager exists and its {@code checkRead}
239 * method doesn't allow read access to the file
240 *
241 * @see SecurityManager#checkRead(java.lang.String)
242 *
243 * @since 1.7
244 */
245 public ZipFile(String name, Charset charset) throws IOException
246 {
247 this(new File(name), OPEN_READ, charset);
248 }
249
250 /**
251 * Opens a ZIP file for reading given the specified File object.
252 *
253 * @param file the ZIP file to be opened for reading
254 * @param charset
255 * The {@linkplain java.nio.charset.Charset charset} to be
256 * used to decode the ZIP entry name and comment (ignored if
257 * the <a href="package-summary.html#lang_encoding"> language
258 * encoding bit</a> of the ZIP entry's general purpose bit
259 * flag is set).
260 *
261 * @throws ZipException if a ZIP format error has occurred
262 * @throws IOException if an I/O error has occurred
263 *
264 * @since 1.7
265 */
266 public ZipFile(File file, Charset charset) throws IOException
267 {
268 this(file, OPEN_READ, charset);
269 }
270
271 /**
272 * Returns the zip file comment, or null if none.
273 *
274 * @return the comment string for the zip file, or null if none
275 *
276 * @throws IllegalStateException if the zip file has been closed
277 *
278 * @since 1.7
279 */
280 public String getComment() {
281 synchronized (this) {
282 ensureOpen();
283 if (zsrc.comment == null) {
284 return null;
285 }
286 return zc.toString(zsrc.comment);
287 }
288 }
289
290 /**
291 * Returns the zip file entry for the specified name, or null
292 * if not found.
293 *
294 * @param name the name of the entry
295 * @return the zip file entry, or null if not found
296 * @throws IllegalStateException if the zip file has been closed
297 */
298 public ZipEntry getEntry(String name) {
299 Objects.requireNonNull(name, "name");
300 synchronized (this) {
301 ensureOpen();
302 byte[] bname = zc.getBytes(name);
303 int pos = zsrc.getEntryPos(bname, true);
304 if (pos != -1) {
305 return getZipEntry(name, bname, pos);
306 }
307 }
308 return null;
309 }
310
311 // The outstanding inputstreams that need to be closed,
312 // mapped to the inflater objects they use.
313 private final Map<InputStream, Inflater> streams = new WeakHashMap<>();
314
315 /**
316 * Returns an input stream for reading the contents of the specified
317 * zip file entry.
318 * <p>
319 * Closing this ZIP file will, in turn, close all input streams that
320 * have been returned by invocations of this method.
321 *
322 * @param entry the zip file entry
323 * @return the input stream for reading the contents of the specified
324 * zip file entry.
325 * @throws ZipException if a ZIP format error has occurred
326 * @throws IOException if an I/O error has occurred
327 * @throws IllegalStateException if the zip file has been closed
328 */
329 public InputStream getInputStream(ZipEntry entry) throws IOException {
330 Objects.requireNonNull(entry, "entry");
331 int pos = -1;
332 ZipFileInputStream in = null;
333 synchronized (this) {
334 ensureOpen();
335 if (Objects.equals(lastEntryName, entry.name)) {
336 pos = lastEntryPos;
337 } else if (!zc.isUTF8() && (entry.flag & EFS) != 0) {
338 pos = zsrc.getEntryPos(zc.getBytesUTF8(entry.name), false);
339 } else {
340 pos = zsrc.getEntryPos(zc.getBytes(entry.name), false);
341 }
342 if (pos == -1) {
343 return null;
344 }
345 in = new ZipFileInputStream(zsrc.cen, pos);
346 switch (CENHOW(zsrc.cen, pos)) {
347 case STORED:
348 synchronized (streams) {
349 streams.put(in, null);
350 }
351 return in;
352 case DEFLATED:
353 // Inflater likes a bit of slack
354 // MORE: Compute good size for inflater stream:
355 long size = CENLEN(zsrc.cen, pos) + 2;
356 if (size > 65536) {
357 size = 8192;
358 }
359 if (size <= 0) {
360 size = 4096;
361 }
362 Inflater inf = getInflater();
363 InputStream is = new ZipFileInflaterInputStream(in, inf, (int)size);
364 synchronized (streams) {
365 streams.put(is, inf);
366 }
367 return is;
368 default:
369 throw new ZipException("invalid compression method");
370 }
371 }
372 }
373
374 private class ZipFileInflaterInputStream extends InflaterInputStream {
375 private volatile boolean closeRequested;
376 private boolean eof = false;
377 private final ZipFileInputStream zfin;
378
379 ZipFileInflaterInputStream(ZipFileInputStream zfin, Inflater inf,
380 int size) {
381 super(zfin, inf, size);
382 this.zfin = zfin;
383 }
384
385 public void close() throws IOException {
386 if (closeRequested)
387 return;
388 closeRequested = true;
389
390 super.close();
391 Inflater inf;
392 synchronized (streams) {
393 inf = streams.remove(this);
394 }
395 if (inf != null) {
396 releaseInflater(inf);
397 }
398 }
399
400 // Override fill() method to provide an extra "dummy" byte
401 // at the end of the input stream. This is required when
402 // using the "nowrap" Inflater option.
403 protected void fill() throws IOException {
404 if (eof) {
405 throw new EOFException("Unexpected end of ZLIB input stream");
406 }
407 len = in.read(buf, 0, buf.length);
408 if (len == -1) {
409 buf[0] = 0;
410 len = 1;
411 eof = true;
412 }
413 inf.setInput(buf, 0, len);
414 }
415
416 public int available() throws IOException {
417 if (closeRequested)
418 return 0;
419 long avail = zfin.size() - inf.getBytesWritten();
420 return (avail > (long) Integer.MAX_VALUE ?
421 Integer.MAX_VALUE : (int) avail);
422 }
423
424 @SuppressWarnings("deprecation")
425 protected void finalize() throws Throwable {
426 close();
427 }
428 }
429
430 /*
431 * Gets an inflater from the list of available inflaters or allocates
432 * a new one.
433 */
434 private Inflater getInflater() {
435 Inflater inf;
436 synchronized (inflaterCache) {
437 while ((inf = inflaterCache.poll()) != null) {
438 if (!inf.ended()) {
439 return inf;
440 }
441 }
442 }
443 return new Inflater(true);
444 }
445
446 /*
447 * Releases the specified inflater to the list of available inflaters.
448 */
449 private void releaseInflater(Inflater inf) {
450 if (!inf.ended()) {
451 inf.reset();
452 synchronized (inflaterCache) {
453 inflaterCache.add(inf);
454 }
455 }
456 }
457
458 // List of available Inflater objects for decompression
459 private final Deque<Inflater> inflaterCache = new ArrayDeque<>();
460
461 /**
462 * Returns the path name of the ZIP file.
463 * @return the path name of the ZIP file
464 */
465 public String getName() {
466 return name;
467 }
468
469 private class ZipEntryIterator implements Enumeration<ZipEntry>, Iterator<ZipEntry> {
470 private int i = 0;
471 private final int entryCount;
472
473 public ZipEntryIterator() {
474 synchronized (ZipFile.this) {
475 ensureOpen();
476 this.entryCount = zsrc.total;
477 }
478 }
479
480 public boolean hasMoreElements() {
481 return hasNext();
482 }
483
484 public boolean hasNext() {
485 return i < entryCount;
486 }
487
488 public ZipEntry nextElement() {
489 return next();
490 }
491
492 public ZipEntry next() {
493 synchronized (ZipFile.this) {
494 ensureOpen();
495 if (!hasNext()) {
496 throw new NoSuchElementException();
497 }
498 // each "entry" has 3 ints in table entries
499 return getZipEntry(null, null, zsrc.getEntryPos(i++ * 3));
500 }
501 }
502
503 public Iterator<ZipEntry> asIterator() {
504 return this;
505 }
506 }
507
508 /**
509 * Returns an enumeration of the ZIP file entries.
510 * @return an enumeration of the ZIP file entries
511 * @throws IllegalStateException if the zip file has been closed
512 */
513 public Enumeration<? extends ZipEntry> entries() {
514 return new ZipEntryIterator();
515 }
516
517 /**
518 * Returns an ordered {@code Stream} over the ZIP file entries.
519 * Entries appear in the {@code Stream} in the order they appear in
520 * the central directory of the ZIP file.
521 *
522 * @return an ordered {@code Stream} of entries in this ZIP file
523 * @throws IllegalStateException if the zip file has been closed
524 * @since 1.8
525 */
526 public Stream<? extends ZipEntry> stream() {
527 return StreamSupport.stream(Spliterators.spliterator(
528 new ZipEntryIterator(), size(),
529 Spliterator.ORDERED | Spliterator.DISTINCT |
530 Spliterator.IMMUTABLE | Spliterator.NONNULL), false);
531 }
532
533 private String lastEntryName;
534 private int lastEntryPos;
535
536 /* Checks ensureOpen() before invoke this method */
537 private ZipEntry getZipEntry(String name, byte[] bname, int pos) {
538 byte[] cen = zsrc.cen;
539 int nlen = CENNAM(cen, pos);
540 int elen = CENEXT(cen, pos);
541 int clen = CENCOM(cen, pos);
542 int flag = CENFLG(cen, pos);
543 if (name == null || bname.length != nlen) {
544 // to use the entry name stored in cen, if the passed in name is
545 // (1) null, invoked from iterator, or
546 // (2) not equal to the name stored, a slash is appended during
547 // getEntryPos() search.
548 if (!zc.isUTF8() && (flag & EFS) != 0) {
549 name = zc.toStringUTF8(cen, pos + CENHDR, nlen);
550 } else {
551 name = zc.toString(cen, pos + CENHDR, nlen);
552 }
553 }
554 ZipEntry e = new ZipEntry(name);
555 e.flag = flag;
556 e.xdostime = CENTIM(cen, pos);
557 e.crc = CENCRC(cen, pos);
558 e.size = CENLEN(cen, pos);
559 e.csize = CENSIZ(cen, pos);
560 e.method = CENHOW(cen, pos);
561 if (elen != 0) {
562 int start = pos + CENHDR + nlen;
563 e.setExtra0(Arrays.copyOfRange(cen, start, start + elen), true);
564 }
565 if (clen != 0) {
566 int start = pos + CENHDR + nlen + elen;
567 if (!zc.isUTF8() && (flag & EFS) != 0) {
568 e.comment = zc.toStringUTF8(cen, start, clen);
569 } else {
570 e.comment = zc.toString(cen, start, clen);
571 }
572 }
573 lastEntryName = e.name;
574 lastEntryPos = pos;
575 return e;
576 }
577
578 /**
579 * Returns the number of entries in the ZIP file.
580 *
581 * @return the number of entries in the ZIP file
582 * @throws IllegalStateException if the zip file has been closed
583 */
584 public int size() {
585 synchronized (this) {
586 ensureOpen();
587 return zsrc.total;
588 }
589 }
590
591 /**
592 * Closes the ZIP file.
593 * <p> Closing this ZIP file will close all of the input streams
594 * previously returned by invocations of the {@link #getInputStream
595 * getInputStream} method.
596 *
597 * @throws IOException if an I/O error has occurred
598 */
599 public void close() throws IOException {
600 if (closeRequested) {
601 return;
602 }
603 closeRequested = true;
604
605 synchronized (this) {
606 // Close streams, release their inflaters
607 synchronized (streams) {
608 if (!streams.isEmpty()) {
609 Map<InputStream, Inflater> copy = new HashMap<>(streams);
610 streams.clear();
611 for (Map.Entry<InputStream, Inflater> e : copy.entrySet()) {
612 e.getKey().close();
613 Inflater inf = e.getValue();
614 if (inf != null) {
615 inf.end();
616 }
617 }
618 }
619 }
620 // Release cached inflaters
621 synchronized (inflaterCache) {
622 Inflater inf;
623 while ((inf = inflaterCache.poll()) != null) {
624 inf.end();
625 }
626 }
627 // Release zip src
628 if (zsrc != null) {
629 Source.close(zsrc);
630 zsrc = null;
631 }
632 }
633 }
634
635 /**
636 * Ensures that the system resources held by this ZipFile object are
637 * released when there are no more references to it.
638 *
639 * <p>
640 * Since the time when GC would invoke this method is undetermined,
641 * it is strongly recommended that applications invoke the {@code close}
642 * method as soon they have finished accessing this {@code ZipFile}.
643 * This will prevent holding up system resources for an undetermined
644 * length of time.
645 *
646 * @deprecated The {@code finalize} method has been deprecated.
647 * Subclasses that override {@code finalize} in order to perform cleanup
648 * should be modified to use alternative cleanup mechanisms and
649 * to remove the overriding {@code finalize} method.
650 * When overriding the {@code finalize} method, its implementation must explicitly
651 * ensure that {@code super.finalize()} is invoked as described in {@link Object#finalize}.
652 * See the specification for {@link Object#finalize()} for further
653 * information about migration options.
654 * @throws IOException if an I/O error has occurred
655 * @see java.util.zip.ZipFile#close()
656 */
657 @Deprecated(since="9")
658 protected void finalize() throws IOException {
659 close();
660 }
661
662 private void ensureOpen() {
663 if (closeRequested) {
664 throw new IllegalStateException("zip file closed");
665 }
666 if (zsrc == null) {
667 throw new IllegalStateException("The object is not initialized.");
668 }
669 }
670
671 private void ensureOpenOrZipException() throws IOException {
672 if (closeRequested) {
673 throw new ZipException("ZipFile closed");
674 }
675 }
676
677 /*
678 * Inner class implementing the input stream used to read a
679 * (possibly compressed) zip file entry.
680 */
681 private class ZipFileInputStream extends InputStream {
682 private volatile boolean closeRequested;
683 private long pos; // current position within entry data
684 protected long rem; // number of remaining bytes within entry
685 protected long size; // uncompressed size of this entry
686
687 ZipFileInputStream(byte[] cen, int cenpos) throws IOException {
688 rem = CENSIZ(cen, cenpos);
689 size = CENLEN(cen, cenpos);
690 pos = CENOFF(cen, cenpos);
691 // zip64
692 if (rem == ZIP64_MAGICVAL || size == ZIP64_MAGICVAL ||
693 pos == ZIP64_MAGICVAL) {
694 checkZIP64(cen, cenpos);
695 }
696 // negative for lazy initialization, see getDataOffset();
697 pos = - (pos + ZipFile.this.zsrc.locpos);
698 }
699
700 private void checkZIP64(byte[] cen, int cenpos) throws IOException {
701 int off = cenpos + CENHDR + CENNAM(cen, cenpos);
702 int end = off + CENEXT(cen, cenpos);
703 while (off + 4 < end) {
704 int tag = get16(cen, off);
705 int sz = get16(cen, off + 2);
706 off += 4;
707 if (off + sz > end) // invalid data
708 break;
709 if (tag == EXTID_ZIP64) {
710 if (size == ZIP64_MAGICVAL) {
711 if (sz < 8 || (off + 8) > end)
712 break;
713 size = get64(cen, off);
714 sz -= 8;
715 off += 8;
716 }
717 if (rem == ZIP64_MAGICVAL) {
718 if (sz < 8 || (off + 8) > end)
719 break;
720 rem = get64(cen, off);
721 sz -= 8;
722 off += 8;
723 }
724 if (pos == ZIP64_MAGICVAL) {
725 if (sz < 8 || (off + 8) > end)
726 break;
727 pos = get64(cen, off);
728 sz -= 8;
729 off += 8;
730 }
731 break;
732 }
733 off += sz;
734 }
735 }
736
737 /* The Zip file spec explicitly allows the LOC extra data size to
738 * be different from the CEN extra data size. Since we cannot trust
739 * the CEN extra data size, we need to read the LOC to determine
740 * the entry data offset.
741 */
742 private long initDataOffset() throws IOException {
743 if (pos <= 0) {
744 byte[] loc = new byte[LOCHDR];
745 pos = -pos;
746 int len = ZipFile.this.zsrc.readFullyAt(loc, 0, loc.length, pos);
747 if (len != LOCHDR) {
748 throw new ZipException("ZipFile error reading zip file");
749 }
750 if (LOCSIG(loc) != LOCSIG) {
751 throw new ZipException("ZipFile invalid LOC header (bad signature)");
752 }
753 pos += LOCHDR + LOCNAM(loc) + LOCEXT(loc);
754 }
755 return pos;
756 }
757
758 public int read(byte b[], int off, int len) throws IOException {
759 synchronized (ZipFile.this) {
760 ensureOpenOrZipException();
761 initDataOffset();
762 if (rem == 0) {
763 return -1;
764 }
765 if (len > rem) {
766 len = (int) rem;
767 }
768 if (len <= 0) {
769 return 0;
770 }
771 len = ZipFile.this.zsrc.readAt(b, off, len, pos);
772 if (len > 0) {
773 pos += len;
774 rem -= len;
775 }
776 }
777 if (rem == 0) {
778 close();
779 }
780 return len;
781 }
782
783 public int read() throws IOException {
784 byte[] b = new byte[1];
785 if (read(b, 0, 1) == 1) {
786 return b[0] & 0xff;
787 } else {
788 return -1;
789 }
790 }
791
792 public long skip(long n) throws IOException {
793 synchronized (ZipFile.this) {
794 ensureOpenOrZipException();
795 initDataOffset();
796 if (n > rem) {
797 n = rem;
798 }
799 pos += n;
800 rem -= n;
801 }
802 if (rem == 0) {
803 close();
804 }
805 return n;
806 }
807
808 public int available() {
809 return rem > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) rem;
810 }
811
812 public long size() {
813 return size;
814 }
815
816 public void close() {
817 if (closeRequested) {
818 return;
819 }
820 closeRequested = true;
821 rem = 0;
822 synchronized (streams) {
823 streams.remove(this);
824 }
825 }
826
827 @SuppressWarnings("deprecation")
828 protected void finalize() {
829 close();
830 }
831 }
832
833 /**
834 * Returns the names of all non-directory entries that begin with
835 * "META-INF/" (case ignored). This method is used in JarFile, via
836 * SharedSecrets, as an optimization when looking up manifest and
837 * signature file entries. Returns null if no entries were found.
838 */
839 private String[] getMetaInfEntryNames() {
840 synchronized (this) {
841 ensureOpen();
842 if (zsrc.metanames == null) {
843 return null;
844 }
845 String[] names = new String[zsrc.metanames.length];
846 byte[] cen = zsrc.cen;
847 for (int i = 0; i < names.length; i++) {
848 int pos = zsrc.metanames[i];
849 names[i] = new String(cen, pos + CENHDR, CENNAM(cen, pos),
850 StandardCharsets.UTF_8);
851 }
852 return names;
853 }
854 }
855
856 private static boolean isWindows;
857 static {
858 SharedSecrets.setJavaUtilZipFileAccess(
859 new JavaUtilZipFileAccess() {
860 public boolean startsWithLocHeader(ZipFile zip) {
861 return zip.zsrc.startsWithLoc;
862 }
863 public String[] getMetaInfEntryNames(ZipFile zip) {
864 return zip.getMetaInfEntryNames();
865 }
866 }
867 );
868 isWindows = VM.getSavedProperty("os.name").contains("Windows");
869 }
870
871 private static class Source {
872 private final Key key; // the key in files
873 private int refs = 1;
874
875 private RandomAccessFile zfile; // zfile of the underlying zip file
876 private byte[] cen; // CEN & ENDHDR
877 private long locpos; // position of first LOC header (usually 0)
878 private byte[] comment; // zip file comment
879 // list of meta entries in META-INF dir
880 private int[] metanames;
881 private final boolean startsWithLoc; // true, if zip file starts with LOCSIG (usually true)
882
883 // A Hashmap for all entries.
884 //
885 // A cen entry of Zip/JAR file. As we have one for every entry in every active Zip/JAR,
886 // We might have a lot of these in a typical system. In order to save space we don't
887 // keep the name in memory, but merely remember a 32 bit {@code hash} value of the
888 // entry name and its offset {@code pos} in the central directory hdeader.
889 //
890 // private static class Entry {
891 // int hash; // 32 bit hashcode on name
892 // int next; // hash chain: index into entries
893 // int pos; // Offset of central directory file header
894 // }
895 // private Entry[] entries; // array of hashed cen entry
896 //
897 // To reduce the total size of entries further, we use a int[] here to store 3 "int"
898 // {@code hash}, {@code next and {@code "pos for each entry. The entry can then be
899 // referred by their index of their positions in the {@code entries}.
900 //
901 private int[] entries; // array of hashed cen entry
902 private int addEntry(int index, int hash, int next, int pos) {
903 entries[index++] = hash;
904 entries[index++] = next;
905 entries[index++] = pos;
906 return index;
907 }
908 private int getEntryHash(int index) { return entries[index]; }
909 private int getEntryNext(int index) { return entries[index + 1]; }
910 private int getEntryPos(int index) { return entries[index + 2]; }
911 private static final int ZIP_ENDCHAIN = -1;
912 private int total; // total number of entries
913 private int[] table; // Hash chain heads: indexes into entries
914 private int tablelen; // number of hash heads
915
916 private static class Key {
917 BasicFileAttributes attrs;
918 File file;
919
920 public Key(File file, BasicFileAttributes attrs) {
921 this.attrs = attrs;
922 this.file = file;
923 }
924
925 public int hashCode() {
926 long t = attrs.lastModifiedTime().toMillis();
927 return ((int)(t ^ (t >>> 32))) + file.hashCode();
928 }
929
930 public boolean equals(Object obj) {
931 if (obj instanceof Key) {
932 Key key = (Key)obj;
933 if (!attrs.lastModifiedTime().equals(key.attrs.lastModifiedTime())) {
934 return false;
935 }
936 Object fk = attrs.fileKey();
937 if (fk != null) {
938 return fk.equals(key.attrs.fileKey());
939 } else {
940 return file.equals(key.file);
941 }
942 }
943 return false;
944 }
945 }
946 private static final HashMap<Key, Source> files = new HashMap<>();
947
948
949 public static Source get(File file, boolean toDelete) throws IOException {
950 Key key = new Key(file,
951 Files.readAttributes(file.toPath(), BasicFileAttributes.class));
952 Source src = null;
953 synchronized (files) {
954 src = files.get(key);
955 if (src != null) {
956 src.refs++;
957 return src;
958 }
959 }
960 src = new Source(key, toDelete);
961
962 synchronized (files) {
963 if (files.containsKey(key)) { // someone else put in first
964 src.close(); // close the newly created one
965 src = files.get(key);
966 src.refs++;
967 return src;
968 }
969 files.put(key, src);
970 return src;
971 }
972 }
973
974 private static void close(Source src) throws IOException {
975 synchronized (files) {
976 if (--src.refs == 0) {
977 files.remove(src.key);
978 src.close();
979 }
980 }
981 }
982
983 private Source(Key key, boolean toDelete) throws IOException {
984 this.key = key;
985 if (toDelete) {
986 if (isWindows) {
987 this.zfile = SharedSecrets.getJavaIORandomAccessFileAccess()
988 .openAndDelete(key.file, "r");
989 } else {
990 this.zfile = new RandomAccessFile(key.file, "r");
991 key.file.delete();
992 }
993 } else {
994 this.zfile = new RandomAccessFile(key.file, "r");
995 }
996 try {
997 initCEN(-1);
998 byte[] buf = new byte[4];
999 readFullyAt(buf, 0, 4, 0);
1000 this.startsWithLoc = (LOCSIG(buf) == LOCSIG);
1001 } catch (IOException x) {
1002 try {
1003 this.zfile.close();
1004 } catch (IOException xx) {}
1005 throw x;
1006 }
1007 }
1008
1009 private void close() throws IOException {
1010 zfile.close();
1011 zfile = null;
1012 cen = null;
1013 entries = null;
1014 table = null;
1015 metanames = null;
1016 }
1017
1018 private static final int BUF_SIZE = 8192;
1019 private final int readFullyAt(byte[] buf, int off, int len, long pos)
1020 throws IOException
1021 {
1022 synchronized(zfile) {
1023 zfile.seek(pos);
1024 int N = len;
1025 while (N > 0) {
1026 int n = Math.min(BUF_SIZE, N);
1027 zfile.readFully(buf, off, n);
1028 off += n;
1029 N -= n;
1030 }
1031 return len;
1032 }
1033 }
1034
1035 private final int readAt(byte[] buf, int off, int len, long pos)
1036 throws IOException
1037 {
1038 synchronized(zfile) {
1039 zfile.seek(pos);
1040 return zfile.read(buf, off, len);
1041 }
1042 }
1043
1044 private static final int hashN(byte[] a, int off, int len) {
1045 int h = 1;
1046 while (len-- > 0) {
1047 h = 31 * h + a[off++];
1048 }
1049 return h;
1050 }
1051
1052 private static final int hash_append(int hash, byte b) {
1053 return hash * 31 + b;
1054 }
1055
1056 private static class End {
1057 int centot; // 4 bytes
1058 long cenlen; // 4 bytes
1059 long cenoff; // 4 bytes
1060 long endpos; // 4 bytes
1061 }
1062
1063 /*
1064 * Searches for end of central directory (END) header. The contents of
1065 * the END header will be read and placed in endbuf. Returns the file
1066 * position of the END header, otherwise returns -1 if the END header
1067 * was not found or an error occurred.
1068 */
1069 private End findEND() throws IOException {
1070 long ziplen = zfile.length();
1071 if (ziplen <= 0)
1072 zerror("zip file is empty");
1073 End end = new End();
1074 byte[] buf = new byte[READBLOCKSZ];
1075 long minHDR = (ziplen - END_MAXLEN) > 0 ? ziplen - END_MAXLEN : 0;
1076 long minPos = minHDR - (buf.length - ENDHDR);
1077 for (long pos = ziplen - buf.length; pos >= minPos; pos -= (buf.length - ENDHDR)) {
1078 int off = 0;
1079 if (pos < 0) {
1080 // Pretend there are some NUL bytes before start of file
1081 off = (int)-pos;
1082 Arrays.fill(buf, 0, off, (byte)0);
1083 }
1084 int len = buf.length - off;
1085 if (readFullyAt(buf, off, len, pos + off) != len ) {
1086 zerror("zip END header not found");
1087 }
1088 // Now scan the block backwards for END header signature
1089 for (int i = buf.length - ENDHDR; i >= 0; i--) {
1090 if (buf[i+0] == (byte)'P' &&
1091 buf[i+1] == (byte)'K' &&
1092 buf[i+2] == (byte)'\005' &&
1093 buf[i+3] == (byte)'\006') {
1094 // Found ENDSIG header
1095 byte[] endbuf = Arrays.copyOfRange(buf, i, i + ENDHDR);
1096 end.centot = ENDTOT(endbuf);
1097 end.cenlen = ENDSIZ(endbuf);
1098 end.cenoff = ENDOFF(endbuf);
1099 end.endpos = pos + i;
1100 int comlen = ENDCOM(endbuf);
1101 if (end.endpos + ENDHDR + comlen != ziplen) {
1102 // ENDSIG matched, however the size of file comment in it does
1103 // not match the real size. One "common" cause for this problem
1104 // is some "extra" bytes are padded at the end of the zipfile.
1105 // Let's do some extra verification, we don't care about the
1106 // performance in this situation.
1107 byte[] sbuf = new byte[4];
1108 long cenpos = end.endpos - end.cenlen;
1109 long locpos = cenpos - end.cenoff;
1110 if (cenpos < 0 ||
1111 locpos < 0 ||
1112 readFullyAt(sbuf, 0, sbuf.length, cenpos) != 4 ||
1113 GETSIG(sbuf) != CENSIG ||
1114 readFullyAt(sbuf, 0, sbuf.length, locpos) != 4 ||
1115 GETSIG(sbuf) != LOCSIG) {
1116 continue;
1117 }
1118 }
1119 if (comlen > 0) { // this zip file has comlen
1120 comment = new byte[comlen];
1121 if (readFullyAt(comment, 0, comlen, end.endpos + ENDHDR) != comlen) {
1122 zerror("zip comment read failed");
1123 }
1124 }
1125 // must check for a zip64 end record; it is always permitted to be present
1126 try {
1127 byte[] loc64 = new byte[ZIP64_LOCHDR];
1128 if (end.endpos < ZIP64_LOCHDR ||
1129 readFullyAt(loc64, 0, loc64.length, end.endpos - ZIP64_LOCHDR)
1130 != loc64.length || GETSIG(loc64) != ZIP64_LOCSIG) {
1131 return end;
1132 }
1133 long end64pos = ZIP64_LOCOFF(loc64);
1134 byte[] end64buf = new byte[ZIP64_ENDHDR];
1135 if (readFullyAt(end64buf, 0, end64buf.length, end64pos)
1136 != end64buf.length || GETSIG(end64buf) != ZIP64_ENDSIG) {
1137 return end;
1138 }
1139 // end64 candidate found,
1140 long cenlen64 = ZIP64_ENDSIZ(end64buf);
1141 long cenoff64 = ZIP64_ENDOFF(end64buf);
1142 long centot64 = ZIP64_ENDTOT(end64buf);
1143 // double-check
1144 if (cenlen64 != end.cenlen && end.cenlen != ZIP64_MAGICVAL ||
1145 cenoff64 != end.cenoff && end.cenoff != ZIP64_MAGICVAL ||
1146 centot64 != end.centot && end.centot != ZIP64_MAGICCOUNT) {
1147 return end;
1148 }
1149 // to use the end64 values
1150 end.cenlen = cenlen64;
1151 end.cenoff = cenoff64;
1152 end.centot = (int)centot64; // assume total < 2g
1153 end.endpos = end64pos;
1154 } catch (IOException x) {} // no zip64 loc/end
1155 return end;
1156 }
1157 }
1158 }
1159 zerror("zip END header not found");
1160 return null; //make compiler happy
1161 }
1162
1163 // Reads zip file central directory.
1164 private void initCEN(int knownTotal) throws IOException {
1165 if (knownTotal == -1) {
1166 End end = findEND();
1167 if (end.endpos == 0) {
1168 locpos = 0;
1169 total = 0;
1170 entries = new int[0];
1171 cen = null;
1172 return; // only END header present
1173 }
1174 if (end.cenlen > end.endpos)
1175 zerror("invalid END header (bad central directory size)");
1176 long cenpos = end.endpos - end.cenlen; // position of CEN table
1177 // Get position of first local file (LOC) header, taking into
1178 // account that there may be a stub prefixed to the zip file.
1179 locpos = cenpos - end.cenoff;
1180 if (locpos < 0) {
1181 zerror("invalid END header (bad central directory offset)");
1182 }
1183 // read in the CEN and END
1184 cen = new byte[(int)(end.cenlen + ENDHDR)];
1185 if (readFullyAt(cen, 0, cen.length, cenpos) != end.cenlen + ENDHDR) {
1186 zerror("read CEN tables failed");
1187 }
1188 total = end.centot;
1189 } else {
1190 total = knownTotal;
1191 }
1192 // hash table for entries
1193 entries = new int[total * 3];
1194 tablelen = ((total/2) | 1); // Odd -> fewer collisions
1195 table = new int[tablelen];
1196 Arrays.fill(table, ZIP_ENDCHAIN);
1197 int idx = 0;
1198 int hash = 0;
1199 int next = -1;
1200
1201 // list for all meta entries
1202 ArrayList<Integer> metanamesList = null;
1203
1204 // Iterate through the entries in the central directory
1205 int i = 0;
1206 int hsh = 0;
1207 int pos = 0;
1208 int limit = cen.length - ENDHDR;
1209 while (pos + CENHDR <= limit) {
1210 if (i >= total) {
1211 // This will only happen if the zip file has an incorrect
1212 // ENDTOT field, which usually means it contains more than
1213 // 65535 entries.
1214 initCEN(countCENHeaders(cen, limit));
1215 return;
1216 }
1217 if (CENSIG(cen, pos) != CENSIG)
1218 zerror("invalid CEN header (bad signature)");
1219 int method = CENHOW(cen, pos);
1220 int nlen = CENNAM(cen, pos);
1221 int elen = CENEXT(cen, pos);
1222 int clen = CENCOM(cen, pos);
1223 if ((CENFLG(cen, pos) & 1) != 0)
1224 zerror("invalid CEN header (encrypted entry)");
1225 if (method != STORED && method != DEFLATED)
1226 zerror("invalid CEN header (bad compression method: " + method + ")");
1227 if (pos + CENHDR + nlen > limit)
1228 zerror("invalid CEN header (bad header size)");
1229 // Record the CEN offset and the name hash in our hash cell.
1230 hash = hashN(cen, pos + CENHDR, nlen);
1231 hsh = (hash & 0x7fffffff) % tablelen;
1232 next = table[hsh];
1233 table[hsh] = idx;
1234 idx = addEntry(idx, hash, next, pos);
1235 // Adds name to metanames.
1236 if (isMetaName(cen, pos + CENHDR, nlen)) {
1237 if (metanamesList == null)
1238 metanamesList = new ArrayList<>(4);
1239 metanamesList.add(pos);
1240 }
1241 // skip ext and comment
1242 pos += (CENHDR + nlen + elen + clen);
1243 i++;
1244 }
1245 total = i;
1246 if (metanamesList != null) {
1247 metanames = new int[metanamesList.size()];
1248 for (int j = 0, len = metanames.length; j < len; j++) {
1249 metanames[j] = metanamesList.get(j);
1250 }
1251 }
1252 if (pos + ENDHDR != cen.length) {
1253 zerror("invalid CEN header (bad header size)");
1254 }
1255 }
1256
1257 private static void zerror(String msg) throws ZipException {
1258 throw new ZipException(msg);
1259 }
1260
1261 /*
1262 * Returns the {@code pos} of the zip cen entry corresponding to the
1263 * specified entry name, or -1 if not found.
1264 */
1265 private int getEntryPos(byte[] name, boolean addSlash) {
1266 if (total == 0) {
1267 return -1;
1268 }
1269 int hsh = hashN(name, 0, name.length);
1270 int idx = table[(hsh & 0x7fffffff) % tablelen];
1271 /*
1272 * This while loop is an optimization where a double lookup
1273 * for name and name+/ is being performed. The name char
1274 * array has enough room at the end to try again with a
1275 * slash appended if the first table lookup does not succeed.
1276 */
1277 while(true) {
1278 /*
1279 * Search down the target hash chain for a entry whose
1280 * 32 bit hash matches the hashed name.
1281 */
1282 while (idx != ZIP_ENDCHAIN) {
1283 if (getEntryHash(idx) == hsh) {
1284 // The CEN name must match the specfied one
1285 int pos = getEntryPos(idx);
1286 if (name.length == CENNAM(cen, pos)) {
1287 boolean matched = true;
1288 int nameoff = pos + CENHDR;
1289 for (int i = 0; i < name.length; i++) {
1290 if (name[i] != cen[nameoff++]) {
1291 matched = false;
1292 break;
1293 }
1294 }
1295 if (matched) {
1296 return pos;
1297 }
1298 }
1299 }
1300 idx = getEntryNext(idx);
1301 }
1302 /* If not addSlash, or slash is already there, we are done */
1303 if (!addSlash || name.length == 0 || name[name.length - 1] == '/') {
1304 return -1;
1305 }
1306 /* Add slash and try once more */
1307 name = Arrays.copyOf(name, name.length + 1);
1308 name[name.length - 1] = '/';
1309 hsh = hash_append(hsh, (byte)'/');
1310 //idx = table[hsh % tablelen];
1311 idx = table[(hsh & 0x7fffffff) % tablelen];
1312 addSlash = false;
1313 }
1314 }
1315
1316 /**
1317 * Returns true if the bytes represent a non-directory name
1318 * beginning with "META-INF/", disregarding ASCII case.
1319 */
1320 private static boolean isMetaName(byte[] name, int off, int len) {
1321 // Use the "oldest ASCII trick in the book"
1322 return len > 9 // "META-INF/".length()
1323 && name[off + len - 1] != '/' // non-directory
1324 && (name[off++] | 0x20) == 'm'
1325 && (name[off++] | 0x20) == 'e'
1326 && (name[off++] | 0x20) == 't'
1327 && (name[off++] | 0x20) == 'a'
1328 && (name[off++] ) == '-'
1329 && (name[off++] | 0x20) == 'i'
1330 && (name[off++] | 0x20) == 'n'
1331 && (name[off++] | 0x20) == 'f'
1332 && (name[off] ) == '/';
1333 }
1334
1335 /**
1336 * Returns the number of CEN headers in a central directory.
1337 * Will not throw, even if the zip file is corrupt.
1338 *
1339 * @param cen copy of the bytes in a zip file's central directory
1340 * @param size number of bytes in central directory
1341 */
1342 private static int countCENHeaders(byte[] cen, int size) {
1343 int count = 0;
1344 for (int p = 0;
1345 p + CENHDR <= size;
1346 p += CENHDR + CENNAM(cen, p) + CENEXT(cen, p) + CENCOM(cen, p))
1347 count++;
1348 return count;
1349 }
1350 }
1351 }