private final String filePath; // ZIP file path

private final String fileName; // name of the file

// Used when decoding entry names and comments

private final ZipCoder zipCoder;

private volatile boolean closeRequested;

// An object holding state which needs to be cleaned after

// this ZipFile is closed or becomes unreachable:

// a) the input streams that need to be closed

// b) the list of cached Inflater objects

// c) the Source object providing read access to the actual ZIP file

private final @Stable CleanableResource res;

private static final int STORED = ZipEntry.STORED;

private static final int DEFLATED = ZipEntry.DEFLATED;

/**

public static final int OPEN_READ = 0x1;

/**

public static final int OPEN_DELETE = 0x4;

/**

private static final boolean DISABLE_ZIP64_EXTRA_VALIDATION =

getDisableZip64ExtraFieldValidation();

/**

public ZipFile(String name) throws IOException {

this(new File(name), OPEN_READ);

}

/**

public ZipFile(File file, int mode) throws IOException {

this(file, mode, UTF_8.INSTANCE);

}

/**

public ZipFile(File file) throws ZipException, IOException {

this(file, OPEN_READ);

}

/**

@SuppressWarnings("this-escape")

public ZipFile(File file, int mode, Charset charset) throws IOException

{

if (((mode & OPEN_READ) == 0) ||

((mode & ~(OPEN_READ | OPEN_DELETE)) != 0)) {

throw new IllegalArgumentException("Illegal mode: 0x"+

Integer.toHexString(mode));

}

String name = file.getPath();

file = new File(name);

Objects.requireNonNull(charset, "charset");

this.filePath = name;

this.fileName = file.getName();

long t0 = System.nanoTime();

this.zipCoder = ZipCoder.get(charset);

this.res = new CleanableResource(this, zipCoder, file, mode);

PerfCounter.getZipFileOpenTime().addElapsedTimeFrom(t0);

PerfCounter.getZipFileCount().increment();

}

/**

public ZipFile(String name, Charset charset) throws IOException

{

this(new File(name), OPEN_READ, charset);

}

/**

public ZipFile(File file, Charset charset) throws IOException

{

this(file, OPEN_READ, charset);

}

/**

public String getComment() {

synchronized (this) {

ensureOpen();

if (res.zsrc.comment == null) {

return null;

}

// If there is a problem decoding the byte array which represents

// the ZIP file comment, return null;

try {

return zipCoder.toString(res.zsrc.comment);

} catch (IllegalArgumentException iae) {

return null;

}

}

}

/**

public ZipEntry getEntry(String name) {

Objects.requireNonNull(name, "name");

ZipEntry entry = null;

synchronized (this) {

ensureOpen();

// Look up the name and CEN header position of the entry.

// The resolved name may include a trailing slash.

// See Source::getEntryPos for details.

EntryPos pos = res.zsrc.getEntryPos(name, true, zipCoder);

if (pos != null) {

entry = getZipEntry(pos.name, pos.pos);

}

}

return entry;

}

/**

public InputStream getInputStream(ZipEntry entry) throws IOException {

Objects.requireNonNull(entry, "entry");

int pos;

ZipFileInputStream in;

Source zsrc = res.zsrc;

Set<InputStream> istreams = res.istreams;

synchronized (this) {

ensureOpen();

if (Objects.equals(lastEntryName, entry.name)) {

pos = lastEntryPos;

} else {

EntryPos entryPos = zsrc.getEntryPos(entry.name, false, zipCoder);

if (entryPos != null) {

pos = entryPos.pos;

} else {

pos = -1;

}

}

if (pos == -1) {

return null;

}

in = new ZipFileInputStream(zsrc.cen, pos, entry.locOffset);

switch (CENHOW(zsrc.cen, pos)) {

case STORED:

synchronized (istreams) {

istreams.add(in);

}

return in;

case DEFLATED:

// Inflater likes a bit of slack

// MORE: Compute good size for inflater stream:

long inputBufSize = CENSIZ(zsrc.cen, pos);

if (inputBufSize > 65536 || inputBufSize <= 0) {

inputBufSize = 8192;

}

InputStream is = new ZipFileInflaterInputStream(in, res, (int) inputBufSize);

synchronized (istreams) {

istreams.add(is);

}

return is;

default:

throw new ZipException("invalid compression method");

}

}

}

/**

private static ZipCoder zipCoderFor(final byte[] cen, final int pos, final ZipCoder fallback) {

if (fallback.isUTF8()) {

// the fallback ZipCoder is capable of handling UTF-8,

// so no need to parse the entry flags to determine if

// the entry has UTF-8 flag.

return fallback;

}

if ((CENFLG(cen, pos) & USE_UTF8) != 0) {

// entry requires a UTF-8 ZipCoder

return ZipCoder.UTF8;

}

// entry doesn't require a UTF-8 ZipCoder

return fallback;

}

private static class InflaterCleanupAction implements Runnable {

private final Inflater inf;

private final CleanableResource res;

InflaterCleanupAction(Inflater inf, CleanableResource res) {

this.inf = inf;

this.res = res;

}

@Override

public void run() {

res.releaseInflater(inf);

}

}

private class ZipFileInflaterInputStream extends InflaterInputStream {

private volatile boolean closeRequested;

private boolean eof = false;

private final Cleanable cleanable;

ZipFileInflaterInputStream(ZipFileInputStream zfin,

CleanableResource res, int inputBufSize) {

this(zfin, res, res.getInflater(), inputBufSize);

}

private ZipFileInflaterInputStream(ZipFileInputStream zfin,

CleanableResource res,

Inflater inf, int inputBufSize) {

super(zfin, inf, inputBufSize);

this.cleanable = CleanerFactory.cleaner().register(this,

new InflaterCleanupAction(inf, res));

}

public void close() throws IOException {

if (closeRequested)

return;

closeRequested = true;

super.close();

synchronized (res.istreams) {

res.istreams.remove(this);

}

cleanable.clean();

}

// Override fill() method to provide an extra "dummy" byte

// at the end of the input stream. This is required when

// using the "nowrap" Inflater option.

protected void fill() throws IOException {

if (eof) {

throw new EOFException("Unexpected end of ZLIB input stream");

}

len = in.read(buf, 0, buf.length);

if (len == -1) {

buf[0] = 0;

len = 1;

eof = true;

}

inf.setInput(buf, 0, len);

}

public int available() throws IOException {

if (closeRequested)

return 0;

long avail = ((ZipFileInputStream)in).size() - inf.getBytesWritten();

return (avail > (long) Integer.MAX_VALUE ?

Integer.MAX_VALUE : (int) avail);

}

}

/**

public String getName() {

return filePath;

}

/**

@Override

public String toString() {

return this.fileName

+ "@" + Integer.toHexString(System.identityHashCode(this));

}

private class ZipEntryIterator<T extends ZipEntry>

implements Enumeration<T>, Iterator<T> {

private int i = 0;

private final int entryCount;

public ZipEntryIterator(int entryCount) {

this.entryCount = entryCount;

}

@Override

public boolean hasMoreElements() {

return hasNext();

}

@Override

public boolean hasNext() {

return i < entryCount;

}

@Override

public T nextElement() {

return next();

}

@Override

@SuppressWarnings("unchecked")

public T next() {

synchronized (ZipFile.this) {

ensureOpen();

if (!hasNext()) {

throw new NoSuchElementException();

}

// each "entry" has 3 ints in table entries

int pos = res.zsrc.getEntryPos(i++ * 3);

return (T)getZipEntry(getEntryName(pos), pos);

}

}

@Override

public Iterator<T> asIterator() {

return this;

}

}

/**

public Enumeration<? extends ZipEntry> entries() {

synchronized (this) {

ensureOpen();

return new ZipEntryIterator<ZipEntry>(res.zsrc.total);

}

}

private Enumeration<JarEntry> jarEntries() {

synchronized (this) {

ensureOpen();

return new ZipEntryIterator<JarEntry>(res.zsrc.total);

}

}

private class EntrySpliterator<T> extends Spliterators.AbstractSpliterator<T> {

private int index;

private final int fence;

private final IntFunction<T> gen;

EntrySpliterator(int index, int fence, IntFunction<T> gen) {

super((long)fence,

Spliterator.ORDERED | Spliterator.DISTINCT | Spliterator.IMMUTABLE |

Spliterator.NONNULL);

this.index = index;

this.fence = fence;

this.gen = gen;

}

@Override

public boolean tryAdvance(Consumer<? super T> action) {

if (action == null)

throw new NullPointerException();

if (index >= 0 && index < fence) {

synchronized (ZipFile.this) {

ensureOpen();

action.accept(gen.apply(res.zsrc.getEntryPos(index++ * 3)));

}

return true;

}

return false;

}

}

/**

public Stream<? extends ZipEntry> stream() {

synchronized (this) {

ensureOpen();

return StreamSupport.stream(new EntrySpliterator<>(0, res.zsrc.total,

pos -> getZipEntry(getEntryName(pos), pos)), false);

}

}

private String getEntryName(int pos) {

byte[] cen = res.zsrc.cen;

int nlen = CENNAM(cen, pos);

ZipCoder zc = zipCoderFor(cen, pos, zipCoder);

return zc.toString(cen, pos + CENHDR, nlen);

}

/*

private Stream<String> entryNameStream() {

synchronized (this) {

ensureOpen();

return StreamSupport.stream(

new EntrySpliterator<>(0, res.zsrc.total, this::getEntryName), false);

}

}

/*

private Stream<JarEntry> jarStream() {

synchronized (this) {

ensureOpen();

return StreamSupport.stream(new EntrySpliterator<>(0, res.zsrc.total,

pos -> (JarEntry)getZipEntry(getEntryName(pos), pos)), false);

}

}

private String lastEntryName;

private int lastEntryPos;

/* Check ensureOpen() before invoking this method */

private ZipEntry getZipEntry(String name, int pos) {

byte[] cen = res.zsrc.cen;

ZipEntry e = this instanceof JarFile jarFile

? Source.JUJA.entryFor(jarFile, name)

: new ZipEntry(name);

e.flag = CENFLG(cen, pos);

e.xdostime = CENTIM(cen, pos);

e.crc = CENCRC(cen, pos);

e.size = CENLEN(cen, pos);

e.csize = CENSIZ(cen, pos);

e.method = CENHOW(cen, pos);

if (CENVEM_FA(cen, pos) == FILE_ATTRIBUTES_UNIX) {

// read all bits in this field, including sym link attributes

e.externalFileAttributes = CENATX_PERMS(cen, pos) & 0xFFFF;

}

e.locOffset = CENOFF(cen, pos);

int nlen = CENNAM(cen, pos);

int elen = CENEXT(cen, pos);

int clen = CENCOM(cen, pos);

if (elen != 0) {

int start = pos + CENHDR + nlen;

e.setExtra0(Arrays.copyOfRange(cen, start, start + elen), true, false);

}

if (clen != 0) {

int start = pos + CENHDR + nlen + elen;

ZipCoder zc = zipCoderFor(cen, pos, zipCoder);

e.comment = zc.toString(cen, start, clen);

}

lastEntryName = e.name;

lastEntryPos = pos;

return e;

}

/**

public int size() {

synchronized (this) {

ensureOpen();

return res.zsrc.total;

}

}

private static class CleanableResource implements Runnable {

// The outstanding inputstreams that need to be closed

final Set<InputStream> istreams;

// List of cached Inflater objects for decompression

List<Inflater> inflaterCache;

final Cleanable cleanable;

Source zsrc;

CleanableResource(ZipFile zf, ZipCoder zipCoder, File file, int mode) throws IOException {

assert zipCoder != null : "null ZipCoder";

this.cleanable = CleanerFactory.cleaner().register(zf, this);

this.istreams = Collections.newSetFromMap(new WeakHashMap<>());

this.inflaterCache = new ArrayList<>();

this.zsrc = Source.get(file, (mode & OPEN_DELETE) != 0, zipCoder);

}

void clean() {

cleanable.clean();

}

/*

Inflater getInflater() {

synchronized (inflaterCache) {

if (!inflaterCache.isEmpty()) {

// return the most recently used Inflater from the cache of not-in-use Inflaters

return inflaterCache.removeLast();

}

}

return new Inflater(true);

}

/*

void releaseInflater(Inflater inf) {

List<Inflater> inflaters = this.inflaterCache;

if (inflaters != null) {

synchronized (inflaters) {

// double checked!

if (inflaters == this.inflaterCache) {

inf.reset();

inflaters.add(inf);

return;

}

}

}

// inflaters cache already closed - just end it.

inf.end();

}

public void run() {

IOException ioe = null;

// Release cached inflaters and close the cache first

List<Inflater> inflaters = this.inflaterCache;

if (inflaters != null) {

synchronized (inflaters) {

// no need to double-check as only one thread gets a

// chance to execute run() (Cleaner guarantee)...

for (Inflater inf : inflaters) {

inf.end();

}

// close inflaters cache

this.inflaterCache = null;

}

}

// Close streams, release their inflaters

synchronized (istreams) {

if (!istreams.isEmpty()) {

InputStream[] copy = istreams.toArray(new InputStream[0]);

istreams.clear();

for (InputStream is : copy) {

try {

is.close();

} catch (IOException e) {

if (ioe == null) ioe = e;

else ioe.addSuppressed(e);

}

}

}

}

// Release ZIP src

if (zsrc != null) {

synchronized (zsrc) {

try {

Source.release(zsrc);

zsrc = null;

} catch (IOException e) {

if (ioe == null) ioe = e;

else ioe.addSuppressed(e);

}

}

}

if (ioe != null) {

throw new UncheckedIOException(ioe);

}

}

}

/**

public void close() throws IOException {

if (closeRequested) {

return;

}

closeRequested = true;

synchronized (this) {

// Close streams, release their inflaters, release cached inflaters

// and release ZIP source

try {

res.clean();

} catch (UncheckedIOException ioe) {

throw ioe.getCause();

}

}

}

private void ensureOpen() {

if (closeRequested) {

throw new IllegalStateException("zip file closed");

}

if (res.zsrc == null) {

throw new IllegalStateException("The object is not initialized.");

}

}

private void ensureOpenOrZipException() throws IOException {

if (closeRequested) {

throw new ZipException("ZipFile closed");

}

}

/*

private class ZipFileInputStream extends InputStream {

private volatile boolean closeRequested;

private long pos; // current position within entry data

private long startingPos; // Start position for the entry data

protected long rem; // number of remaining bytes within entry

protected long size; // uncompressed size of this entry

/**

ZipFileInputStream(byte[] cen, int cenpos, long locOffset) {

rem = CENSIZ(cen, cenpos);

size = CENLEN(cen, cenpos);

if (locOffset == -1) {

pos = CENOFF(cen, cenpos);

} else {

pos = locOffset;

}

// ZIP64

if (rem == ZIP64_MAGICVAL || size == ZIP64_MAGICVAL ||

pos == ZIP64_MAGICVAL) {

checkZIP64(cen, cenpos);

}

// negative for lazy initialization, see getDataOffset();

pos = - (pos + ZipFile.this.res.zsrc.locpos);

}

private void checkZIP64(byte[] cen, int cenpos) {

int off = cenpos + CENHDR + CENNAM(cen, cenpos);

int end = off + CENEXT(cen, cenpos);

while (off + 4 < end) {

int tag = get16(cen, off);

int sz = get16(cen, off + 2);

off += 4;

if (off + sz > end) // invalid data

break;

if (tag == EXTID_ZIP64) {

if (size == ZIP64_MAGICVAL) {

if (sz < 8 || (off + 8) > end)

break;

size = get64S(cen, off);

sz -= 8;

off += 8;

}

if (rem == ZIP64_MAGICVAL) {

if (sz < 8 || (off + 8) > end)

break;

rem = get64S(cen, off);

sz -= 8;

off += 8;

}

if (pos == ZIP64_MAGICVAL) {

if (sz < 8 || (off + 8) > end)

break;

pos = get64S(cen, off);

sz -= 8;

off += 8;

}

break;

}

off += sz;

}

}

/*

private long initDataOffset() throws IOException {

if (pos <= 0) {

byte[] loc = new byte[LOCHDR];

pos = -pos;

int len = ZipFile.this.res.zsrc.readFullyAt(loc, 0, loc.length, pos);

if (len != LOCHDR) {

throw new ZipException("ZipFile error reading zip file");

}

if (LOCSIG(loc) != LOCSIG) {

throw new ZipException("ZipFile invalid LOC header (bad signature)");

}

pos += LOCHDR + LOCNAM(loc) + LOCEXT(loc);

startingPos = pos; // Save starting position for the entry

}

return pos;

}

public int read(byte[] b, int off, int len) throws IOException {

synchronized (ZipFile.this) {

ensureOpenOrZipException();

initDataOffset();

if (rem == 0) {

return -1;

}

if (len > rem) {

len = (int) rem;

}

if (len <= 0) {

return 0;

}

len = ZipFile.this.res.zsrc.readAt(b, off, len, pos);

if (len > 0) {

pos += len;

rem -= len;

}

}

if (rem == 0) {

close();

}

return len;

}

public int read() throws IOException {

byte[] b = new byte[1];

if (read(b, 0, 1) == 1) {

return b[0] & 0xff;

} else {

return -1;

}

}

public long skip(long n) throws IOException {

synchronized (ZipFile.this) {

initDataOffset();

long newPos = pos + n;

if (n > 0) {

// If we overflowed adding the skip value or are moving

// past EOF, set the skip value to number of bytes remaining

// to reach EOF

if (newPos < 0 || n > rem) {

n = rem;

}

} else if (newPos < startingPos) {

// Tried to position before BOF so set position to the

// BOF and return the number of bytes we moved backwards

// to reach BOF

n = startingPos - pos;

}

pos += n;

rem -= n;

}

if (rem == 0) {

close();

}

return n;

}

public int available() {

return rem > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) rem;

}

public long size() {

return size;

}