/*

  * 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);

     }

 }