| /* |
| * Copyright (c) 1996, 2009, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package java.util.zip; |
| |
| import java.io.InputStream; |
| import java.io.IOException; |
| import java.io.EOFException; |
| import java.io.PushbackInputStream; |
| import java.nio.charset.Charset; |
| import java.nio.charset.StandardCharsets; |
| import static java.util.zip.ZipConstants64.*; |
| |
| /** |
| * This class implements an input stream filter for reading files in the |
| * ZIP file format. Includes support for both compressed and uncompressed |
| * entries. |
| * |
| * @author David Connelly |
| */ |
| public |
| class ZipInputStream extends InflaterInputStream implements ZipConstants { |
| private ZipEntry entry; |
| private int flag; |
| private CRC32 crc = new CRC32(); |
| private long remaining; |
| private byte[] tmpbuf = new byte[512]; |
| |
| private static final int STORED = ZipEntry.STORED; |
| private static final int DEFLATED = ZipEntry.DEFLATED; |
| |
| private boolean closed = false; |
| // this flag is set to true after EOF has reached for |
| // one entry |
| private boolean entryEOF = false; |
| |
| private ZipCoder zc; |
| |
| /** |
| * Check to make sure that this stream has not been closed |
| */ |
| private void ensureOpen() throws IOException { |
| if (closed) { |
| throw new IOException("Stream closed"); |
| } |
| } |
| |
| /** |
| * Creates a new ZIP input stream. |
| * |
| * <p>The UTF-8 {@link java.nio.charset.Charset charset} is used to |
| * decode the entry names. |
| * |
| * @param in the actual input stream |
| */ |
| public ZipInputStream(InputStream in) { |
| this(in, StandardCharsets.UTF_8); |
| } |
| |
| /** |
| * Creates a new ZIP input stream. |
| * |
| * @param in the actual input stream |
| * |
| * @param charset |
| * The {@linkplain java.nio.charset.Charset charset} to be |
| * used to decode the ZIP entry name (ignored if the |
| * <a href="package-summary.html#lang_encoding"> language |
| * encoding bit</a> of the ZIP entry's general purpose bit |
| * flag is set). |
| * |
| * @since 1.7 |
| */ |
| public ZipInputStream(InputStream in, Charset charset) { |
| super(new PushbackInputStream(in, 512), new Inflater(true), 512); |
| usesDefaultInflater = true; |
| if(in == null) { |
| throw new NullPointerException("in is null"); |
| } |
| if (charset == null) |
| throw new NullPointerException("charset is null"); |
| this.zc = ZipCoder.get(charset); |
| } |
| |
| /** |
| * Reads the next ZIP file entry and positions the stream at the |
| * beginning of the entry data. |
| * @return the next ZIP file entry, or null if there are no more entries |
| * @exception ZipException if a ZIP file error has occurred |
| * @exception IOException if an I/O error has occurred |
| */ |
| public ZipEntry getNextEntry() throws IOException { |
| ensureOpen(); |
| if (entry != null) { |
| closeEntry(); |
| } |
| crc.reset(); |
| inf.reset(); |
| if ((entry = readLOC()) == null) { |
| return null; |
| } |
| if (entry.method == STORED) { |
| remaining = entry.size; |
| } |
| entryEOF = false; |
| return entry; |
| } |
| |
| /** |
| * Closes the current ZIP entry and positions the stream for reading the |
| * next entry. |
| * @exception ZipException if a ZIP file error has occurred |
| * @exception IOException if an I/O error has occurred |
| */ |
| public void closeEntry() throws IOException { |
| ensureOpen(); |
| while (read(tmpbuf, 0, tmpbuf.length) != -1) ; |
| entryEOF = true; |
| } |
| |
| /** |
| * Returns 0 after EOF has reached for the current entry data, |
| * otherwise always return 1. |
| * <p> |
| * Programs should not count on this method to return the actual number |
| * of bytes that could be read without blocking. |
| * |
| * @return 1 before EOF and 0 after EOF has reached for current entry. |
| * @exception IOException if an I/O error occurs. |
| * |
| */ |
| public int available() throws IOException { |
| ensureOpen(); |
| if (entryEOF) { |
| return 0; |
| } else { |
| return 1; |
| } |
| } |
| |
| /** |
| * Reads from the current ZIP entry into an array of bytes. |
| * If <code>len</code> is not zero, the method |
| * blocks until some input is available; otherwise, no |
| * bytes are read and <code>0</code> is returned. |
| * @param b the buffer into which the data is read |
| * @param off the start offset in the destination array <code>b</code> |
| * @param len the maximum number of bytes read |
| * @return the actual number of bytes read, or -1 if the end of the |
| * entry is reached |
| * @exception NullPointerException if <code>b</code> is <code>null</code>. |
| * @exception IndexOutOfBoundsException if <code>off</code> is negative, |
| * <code>len</code> is negative, or <code>len</code> is greater than |
| * <code>b.length - off</code> |
| * @exception ZipException if a ZIP file error has occurred |
| * @exception IOException if an I/O error has occurred |
| */ |
| public int read(byte[] b, int off, int len) throws IOException { |
| ensureOpen(); |
| if (off < 0 || len < 0 || off > b.length - len) { |
| throw new IndexOutOfBoundsException(); |
| } else if (len == 0) { |
| return 0; |
| } |
| |
| if (entry == null) { |
| return -1; |
| } |
| switch (entry.method) { |
| case DEFLATED: |
| len = super.read(b, off, len); |
| if (len == -1) { |
| readEnd(entry); |
| entryEOF = true; |
| entry = null; |
| } else { |
| crc.update(b, off, len); |
| } |
| return len; |
| case STORED: |
| if (remaining <= 0) { |
| entryEOF = true; |
| entry = null; |
| return -1; |
| } |
| if (len > remaining) { |
| len = (int)remaining; |
| } |
| len = in.read(b, off, len); |
| if (len == -1) { |
| throw new ZipException("unexpected EOF"); |
| } |
| crc.update(b, off, len); |
| remaining -= len; |
| if (remaining == 0 && entry.crc != crc.getValue()) { |
| throw new ZipException( |
| "invalid entry CRC (expected 0x" + Long.toHexString(entry.crc) + |
| " but got 0x" + Long.toHexString(crc.getValue()) + ")"); |
| } |
| return len; |
| default: |
| throw new ZipException("invalid compression method"); |
| } |
| } |
| |
| /** |
| * Skips specified number of bytes in the current ZIP entry. |
| * @param n the number of bytes to skip |
| * @return the actual number of bytes skipped |
| * @exception ZipException if a ZIP file error has occurred |
| * @exception IOException if an I/O error has occurred |
| * @exception IllegalArgumentException if n < 0 |
| */ |
| public long skip(long n) throws IOException { |
| if (n < 0) { |
| throw new IllegalArgumentException("negative skip length"); |
| } |
| ensureOpen(); |
| int max = (int)Math.min(n, Integer.MAX_VALUE); |
| int total = 0; |
| while (total < max) { |
| int len = max - total; |
| if (len > tmpbuf.length) { |
| len = tmpbuf.length; |
| } |
| len = read(tmpbuf, 0, len); |
| if (len == -1) { |
| entryEOF = true; |
| break; |
| } |
| total += len; |
| } |
| return total; |
| } |
| |
| /** |
| * Closes this input stream and releases any system resources associated |
| * with the stream. |
| * @exception IOException if an I/O error has occurred |
| */ |
| public void close() throws IOException { |
| if (!closed) { |
| super.close(); |
| closed = true; |
| } |
| } |
| |
| private byte[] b = new byte[256]; |
| |
| /* |
| * Reads local file (LOC) header for next entry. |
| */ |
| private ZipEntry readLOC() throws IOException { |
| try { |
| readFully(tmpbuf, 0, LOCHDR); |
| } catch (EOFException e) { |
| return null; |
| } |
| if (get32(tmpbuf, 0) != LOCSIG) { |
| return null; |
| } |
| // get flag first, we need check EFS. |
| flag = get16(tmpbuf, LOCFLG); |
| // get the entry name and create the ZipEntry first |
| int len = get16(tmpbuf, LOCNAM); |
| int blen = b.length; |
| if (len > blen) { |
| do |
| blen = blen * 2; |
| while (len > blen); |
| b = new byte[blen]; |
| } |
| readFully(b, 0, len); |
| // Force to use UTF-8 if the EFS bit is ON, even the cs is NOT UTF-8 |
| ZipEntry e = createZipEntry(((flag & EFS) != 0) |
| ? zc.toStringUTF8(b, len) |
| : zc.toString(b, len)); |
| // now get the remaining fields for the entry |
| if ((flag & 1) == 1) { |
| throw new ZipException("encrypted ZIP entry not supported"); |
| } |
| e.method = get16(tmpbuf, LOCHOW); |
| e.time = get32(tmpbuf, LOCTIM); |
| if ((flag & 8) == 8) { |
| /* "Data Descriptor" present */ |
| if (e.method != DEFLATED) { |
| throw new ZipException( |
| "only DEFLATED entries can have EXT descriptor"); |
| } |
| } else { |
| e.crc = get32(tmpbuf, LOCCRC); |
| e.csize = get32(tmpbuf, LOCSIZ); |
| e.size = get32(tmpbuf, LOCLEN); |
| } |
| len = get16(tmpbuf, LOCEXT); |
| if (len > 0) { |
| byte[] bb = new byte[len]; |
| readFully(bb, 0, len); |
| e.setExtra(bb); |
| // extra fields are in "HeaderID(2)DataSize(2)Data... format |
| if (e.csize == ZIP64_MAGICVAL || e.size == ZIP64_MAGICVAL) { |
| int off = 0; |
| while (off + 4 < len) { |
| int sz = get16(bb, off + 2); |
| if (get16(bb, off) == ZIP64_EXTID) { |
| off += 4; |
| // LOC extra zip64 entry MUST include BOTH original and |
| // compressed file size fields |
| if (sz < 16 || (off + sz) > len ) { |
| // Invalid zip64 extra fields, simply skip. Even it's |
| // rare, it's possible the entry size happens to be |
| // the magic value and it "accidnetly" has some bytes |
| // in extra match the id. |
| return e; |
| } |
| e.size = get64(bb, off); |
| e.csize = get64(bb, off + 8); |
| break; |
| } |
| off += (sz + 4); |
| } |
| } |
| } |
| return e; |
| } |
| |
| /** |
| * Creates a new <code>ZipEntry</code> object for the specified |
| * entry name. |
| * |
| * @param name the ZIP file entry name |
| * @return the ZipEntry just created |
| */ |
| protected ZipEntry createZipEntry(String name) { |
| return new ZipEntry(name); |
| } |
| |
| /* |
| * Reads end of deflated entry as well as EXT descriptor if present. |
| */ |
| private void readEnd(ZipEntry e) throws IOException { |
| int n = inf.getRemaining(); |
| if (n > 0) { |
| ((PushbackInputStream)in).unread(buf, len - n, n); |
| } |
| if ((flag & 8) == 8) { |
| /* "Data Descriptor" present */ |
| if (inf.getBytesWritten() > ZIP64_MAGICVAL || |
| inf.getBytesRead() > ZIP64_MAGICVAL) { |
| // ZIP64 format |
| readFully(tmpbuf, 0, ZIP64_EXTHDR); |
| long sig = get32(tmpbuf, 0); |
| if (sig != EXTSIG) { // no EXTSIG present |
| e.crc = sig; |
| e.csize = get64(tmpbuf, ZIP64_EXTSIZ - ZIP64_EXTCRC); |
| e.size = get64(tmpbuf, ZIP64_EXTLEN - ZIP64_EXTCRC); |
| ((PushbackInputStream)in).unread( |
| tmpbuf, ZIP64_EXTHDR - ZIP64_EXTCRC - 1, ZIP64_EXTCRC); |
| } else { |
| e.crc = get32(tmpbuf, ZIP64_EXTCRC); |
| e.csize = get64(tmpbuf, ZIP64_EXTSIZ); |
| e.size = get64(tmpbuf, ZIP64_EXTLEN); |
| } |
| } else { |
| readFully(tmpbuf, 0, EXTHDR); |
| long sig = get32(tmpbuf, 0); |
| if (sig != EXTSIG) { // no EXTSIG present |
| e.crc = sig; |
| e.csize = get32(tmpbuf, EXTSIZ - EXTCRC); |
| e.size = get32(tmpbuf, EXTLEN - EXTCRC); |
| ((PushbackInputStream)in).unread( |
| tmpbuf, EXTHDR - EXTCRC - 1, EXTCRC); |
| } else { |
| e.crc = get32(tmpbuf, EXTCRC); |
| e.csize = get32(tmpbuf, EXTSIZ); |
| e.size = get32(tmpbuf, EXTLEN); |
| } |
| } |
| } |
| if (e.size != inf.getBytesWritten()) { |
| throw new ZipException( |
| "invalid entry size (expected " + e.size + |
| " but got " + inf.getBytesWritten() + " bytes)"); |
| } |
| if (e.csize != inf.getBytesRead()) { |
| throw new ZipException( |
| "invalid entry compressed size (expected " + e.csize + |
| " but got " + inf.getBytesRead() + " bytes)"); |
| } |
| if (e.crc != crc.getValue()) { |
| throw new ZipException( |
| "invalid entry CRC (expected 0x" + Long.toHexString(e.crc) + |
| " but got 0x" + Long.toHexString(crc.getValue()) + ")"); |
| } |
| } |
| |
| /* |
| * Reads bytes, blocking until all bytes are read. |
| */ |
| private void readFully(byte[] b, int off, int len) throws IOException { |
| while (len > 0) { |
| int n = in.read(b, off, len); |
| if (n == -1) { |
| throw new EOFException(); |
| } |
| off += n; |
| len -= n; |
| } |
| } |
| |
| /* |
| * Fetches unsigned 16-bit value from byte array at specified offset. |
| * The bytes are assumed to be in Intel (little-endian) byte order. |
| */ |
| private static final int get16(byte b[], int off) { |
| return (b[off] & 0xff) | ((b[off+1] & 0xff) << 8); |
| } |
| |
| /* |
| * Fetches unsigned 32-bit value from byte array at specified offset. |
| * The bytes are assumed to be in Intel (little-endian) byte order. |
| */ |
| private static final long get32(byte b[], int off) { |
| return (get16(b, off) | ((long)get16(b, off+2) << 16)) & 0xffffffffL; |
| } |
| |
| /* |
| * Fetches signed 64-bit value from byte array at specified offset. |
| * The bytes are assumed to be in Intel (little-endian) byte order. |
| */ |
| private static final long get64(byte b[], int off) { |
| return get32(b, off) | (get32(b, off+4) << 32); |
| } |
| } |
