mirror of
git://gcc.gnu.org/git/gcc.git
synced 2024-12-23 19:39:56 +08:00
258 lines
6.7 KiB
Java
258 lines
6.7 KiB
Java
/* ZipFile.java - Read contents of a ZIP file
|
|
Copyright (C) 1999, 2000 Free Software Foundation, Inc.
|
|
|
|
This file is part of GNU Classpath.
|
|
|
|
GNU Classpath is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
GNU Classpath 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 for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GNU Classpath; see the file COPYING. If not, write to the
|
|
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
|
02111-1307 USA.
|
|
|
|
As a special exception, if you link this library with other files to
|
|
produce an executable, this library does not by itself cause the
|
|
resulting executable to be covered by the GNU General Public License.
|
|
This exception does not however invalidate any other reasons why the
|
|
executable file might be covered by the GNU General Public License. */
|
|
|
|
package java.util.zip;
|
|
|
|
import java.io.*;
|
|
|
|
/* Written using on-line Java Platform 1.2 API Specification
|
|
* and JCL book.
|
|
* Believed complete and correct.
|
|
*/
|
|
|
|
public class ZipFile implements ZipConstants
|
|
{
|
|
public static final int OPEN_READ = 1;
|
|
public static final int OPEN_DELETE = 4;
|
|
|
|
public ZipFile (String fname) throws IOException
|
|
{
|
|
this(new File(fname));
|
|
}
|
|
|
|
public ZipFile (File f) throws IOException
|
|
{
|
|
this(f, OPEN_READ);
|
|
}
|
|
|
|
public ZipFile (File f, int mode) throws IOException
|
|
{
|
|
if (mode != OPEN_READ && mode != (OPEN_READ | OPEN_DELETE))
|
|
throw new IllegalArgumentException
|
|
("mode can only be OPEN_READ or OPEN_READ | OPEN_DELETE");
|
|
|
|
if ((mode & OPEN_DELETE) != 0)
|
|
{
|
|
delete_on_close = f;
|
|
f.deleteOnExit();
|
|
}
|
|
else
|
|
{
|
|
delete_on_close = null;
|
|
}
|
|
|
|
file = new RandomAccessFile(f, "r");
|
|
name = f.getName();
|
|
readDirectory ();
|
|
}
|
|
|
|
void readDirectory () throws IOException
|
|
{
|
|
long size = file.length ();
|
|
if (size < ZipConstants.END_CENTRAL_DIR_SIZE)
|
|
throw new ZipException ("zipfile too short");
|
|
// We do not handle a "zipfile comment", which the appnote says can
|
|
// be at the end of a .zip file. We could handle this by seeking
|
|
// to the beginning and reading forwards.
|
|
file.seek(size - ZipConstants.END_CENTRAL_DIR_SIZE);
|
|
if (file.read() != 'P'
|
|
|| file.read() != 'K'
|
|
|| file.read() != '\005'
|
|
|| file.read() != '\006')
|
|
throw new ZipException("not a valid zipfile");
|
|
file.skipBytes(6);
|
|
numEntries = readu2();
|
|
int dir_size = read4 (); // Read "size of the central directory".
|
|
file.seek(size - (dir_size + ZipConstants.END_CENTRAL_DIR_SIZE));
|
|
|
|
ZipEntry last = null;
|
|
for (int i = 0; i < numEntries; i++)
|
|
{
|
|
file.skipBytes(10);
|
|
int method = readu2();
|
|
int modtime = readu2();
|
|
int moddate = readu2();
|
|
int crc = read4();
|
|
int compressedSize = read4();
|
|
int uncompressedSize = read4();
|
|
int filenameLength = readu2();
|
|
int extraLength = readu2();
|
|
int commentLength = readu2();
|
|
int diskNumberStart = readu2();
|
|
int intAttributes = readu2();
|
|
int extAttributes = read4();
|
|
int relativeOffset = read4();
|
|
byte[] bname = new byte[filenameLength];
|
|
file.readFully(bname);
|
|
ZipEntry entry = new ZipEntry(new String(bname, "8859_1"));
|
|
if (extraLength > 0)
|
|
{
|
|
byte[] bextra = new byte[extraLength];
|
|
file.readFully(bextra);
|
|
entry.extra = bextra;
|
|
}
|
|
if (commentLength > 0)
|
|
{
|
|
byte[] bcomment = new byte[commentLength];
|
|
file.readFully(bcomment);
|
|
entry.comment = new String(bcomment, "8859_1");
|
|
}
|
|
entry.compressedSize = compressedSize;
|
|
entry.size = uncompressedSize;
|
|
entry.crc = (long) crc & 0xffffffffL;
|
|
entry.method = method;
|
|
entry.relativeOffset = relativeOffset;
|
|
entry.time = ZipEntry.timeFromDOS(moddate, modtime);
|
|
if (last == null)
|
|
entries = entry;
|
|
else
|
|
last.next = entry;
|
|
last = entry;
|
|
}
|
|
}
|
|
|
|
public java.util.Enumeration entries()
|
|
{
|
|
return new ZipEnumeration(this);
|
|
}
|
|
|
|
public void close() throws IOException
|
|
{
|
|
file.close();
|
|
entries = null;
|
|
numEntries = 0;
|
|
if (delete_on_close != null)
|
|
delete_on_close.delete();
|
|
}
|
|
|
|
public ZipEntry getEntry(String name)
|
|
{
|
|
for (ZipEntry entry = entries; entry != null; entry = entry.next)
|
|
{
|
|
if (name.equals(entry.getName()))
|
|
return entry;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public InputStream getInputStream(ZipEntry ze) throws IOException
|
|
{
|
|
byte[] buffer = new byte[(int) ze.getCompressedSize()];
|
|
|
|
/* Read the size of the extra field, and skip to the start of the
|
|
data. */
|
|
file.seek (ze.relativeOffset + ZipConstants.LOCAL_FILE_HEADER_SIZE - 2);
|
|
int extraFieldLength = readu2();
|
|
file.skipBytes (ze.getName().length() + extraFieldLength);
|
|
|
|
file.readFully(buffer);
|
|
|
|
InputStream is = new ByteArrayInputStream (buffer);
|
|
if (ze.getMethod() == ZipEntry.DEFLATED)
|
|
// Data in zipfile entries does not have a zlib header, so construct
|
|
// an Inflater with the `nowrapper' option.
|
|
is = new InflaterInputStream (is, new Inflater (true), 512);
|
|
return is;
|
|
}
|
|
|
|
public String getName ()
|
|
{
|
|
return name;
|
|
}
|
|
|
|
/**
|
|
* Returns the number of entries in this ZipFile.
|
|
* @exception IllegalStateException if the ZipFile has been closed.
|
|
*
|
|
* @since 1.2
|
|
*/
|
|
public int size ()
|
|
{
|
|
if (entries == null)
|
|
throw new IllegalStateException("ZipFile already closed");
|
|
else
|
|
return numEntries;
|
|
}
|
|
|
|
protected void finalize () throws IOException
|
|
{
|
|
close();
|
|
}
|
|
|
|
private int readu2 () throws IOException
|
|
{
|
|
int byte0 = file.read();
|
|
int byte1 = file.read();
|
|
if (byte0 < 0 || byte1 < 0)
|
|
throw new ZipException (".zip archive ended prematurely");
|
|
return ((byte1 & 0xFF) << 8) | (byte0 & 0xFF);
|
|
}
|
|
|
|
private int read4 () throws IOException
|
|
{
|
|
int byte0 = file.read();
|
|
int byte1 = file.read();
|
|
int byte2 = file.read();
|
|
int byte3 = file.read();
|
|
if (byte3 < 0)
|
|
throw new ZipException (".zip archive ended prematurely");
|
|
return ((byte3 & 0xFF) << 24) + ((byte2 & 0xFF) << 16)
|
|
+ ((byte1 & 0xFF) << 8) + (byte0 & 0xFF);
|
|
}
|
|
|
|
ZipEntry entries;
|
|
int numEntries;
|
|
RandomAccessFile file;
|
|
String name;
|
|
/** File to delete on close or null. */
|
|
File delete_on_close;
|
|
|
|
}
|
|
|
|
final class ZipEnumeration implements java.util.Enumeration
|
|
{
|
|
ZipEntry entry;
|
|
|
|
ZipEnumeration (ZipFile zfile)
|
|
{
|
|
entry = zfile.entries;
|
|
}
|
|
|
|
public boolean hasMoreElements ()
|
|
{
|
|
return entry != null;
|
|
}
|
|
|
|
public Object nextElement ()
|
|
{
|
|
ZipEntry cur = entry;
|
|
if (cur == null)
|
|
throw new java.util.NoSuchElementException();
|
|
entry = cur.next;
|
|
return cur;
|
|
}
|
|
}
|