libjava/java/util/zip/ZipFile.java

   1 /* ZipFile.java --
   2    Copyright (C) 2001, 2002, 2003, 2004  Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package java.util.zip;
  40
  41 import java.io.BufferedInputStream;
  42 import java.io.DataInput;
  43 import java.io.EOFException;
  44 import java.io.File;
  45 import java.io.IOException;
  46 import java.io.InputStream;
  47 import java.io.RandomAccessFile;
  48 import java.util.Enumeration;
  49 import java.util.HashMap;
  50 import java.util.Iterator;
  51
  52 /**
  53  * This class represents a Zip archive.  You can ask for the contained
  54  * entries, or get an input stream for a file entry.  The entry is
  55  * automatically decompressed.
  56  *
  57  * This class is thread safe:  You can open input streams for arbitrary
  58  * entries in different threads.
  59  *
  60  * @author Jochen Hoenicke
  61  * @author Artur Biesiadowski
  62  */
  63 public class ZipFile implements ZipConstants
  64 {
  65
  66   /**
  67    * Mode flag to open a zip file for reading.
  68    */
  69   public static final int OPEN_READ = 0x1;
  70
  71   /**
  72    * Mode flag to delete a zip file after reading.
  73    */
  74   public static final int OPEN_DELETE = 0x4;
  75
  76   // Name of this zip file.
  77   private final String name;
  78
  79   // File from which zip entries are read.
  80   private final RandomAccessFile raf;
  81
  82   // The entries of this zip file when initialized and not yet closed.
  83   private HashMap entries;
  84
  85   private boolean closed = false;
  86
  87   /**
  88    * Opens a Zip file with the given name for reading.
  89    * @exception IOException if a i/o error occured.
  90    * @exception ZipException if the file doesn't contain a valid zip
  91    * archive.
  92    */
  93   public ZipFile(String name) throws ZipException, IOException
  94   {
  95     this.raf = new RandomAccessFile(name, "r");
  96     this.name = name;
  97   }
  98
  99   /**
 100    * Opens a Zip file reading the given File.
 101    * @exception IOException if a i/o error occured.
 102    * @exception ZipException if the file doesn't contain a valid zip
 103    * archive.
 104    */
 105   public ZipFile(File file) throws ZipException, IOException
 106   {
 107     this.raf = new RandomAccessFile(file, "r");
 108     this.name = file.getPath();
 109   }
 110
 111   /**
 112    * Opens a Zip file reading the given File in the given mode.
 113    *
 114    * If the OPEN_DELETE mode is specified, the zip file will be deleted at
 115    * some time moment after it is opened. It will be deleted before the zip
 116    * file is closed or the Virtual Machine exits.
 117    *
 118    * The contents of the zip file will be accessible until it is closed.
 119    *
 120    * The OPEN_DELETE mode is currently unimplemented in this library
 121    *
 122    * @since JDK1.3
 123    * @param mode Must be one of OPEN_READ or OPEN_READ | OPEN_DELETE
 124    *
 125    * @exception IOException if a i/o error occured.
 126    * @exception ZipException if the file doesn't contain a valid zip
 127    * archive.
 128    */
 129   public ZipFile(File file, int mode) throws ZipException, IOException
 130   {
 131     if ((mode & OPEN_DELETE) != 0)
 132       {
 133         throw new IllegalArgumentException
 134           ("OPEN_DELETE mode not supported yet in java.util.zip.ZipFile");
 135       }
 136     this.raf = new RandomAccessFile(file, "r");
 137     this.name = file.getPath();
 138   }
 139
 140   /**
 141    * Read an unsigned short in little endian byte order from the given
 142    * DataInput stream using the given byte buffer.
 143    *
 144    * @param di DataInput stream to read from.
 145    * @param b the byte buffer to read in (must be at least 2 bytes long).
 146    * @return The value read.
 147    *
 148    * @exception IOException if a i/o error occured.
 149    * @exception EOFException if the file ends prematurely
 150    */
 151   private int readLeShort(DataInput di, byte[] b) throws IOException
 152   {
 153     di.readFully(b, 0, 2);
 154     return (b[0] & 0xff) | (b[1] & 0xff) << 8;
 155   }
 156
 157   /**
 158    * Read an int in little endian byte order from the given
 159    * DataInput stream using the given byte buffer.
 160    *
 161    * @param di DataInput stream to read from.
 162    * @param b the byte buffer to read in (must be at least 4 bytes long).
 163    * @return The value read.
 164    *
 165    * @exception IOException if a i/o error occured.
 166    * @exception EOFException if the file ends prematurely
 167    */
 168   private int readLeInt(DataInput di, byte[] b) throws IOException
 169   {
 170     di.readFully(b, 0, 4);
 171     return ((b[0] & 0xff) | (b[1] & 0xff) << 8)
 172             | ((b[2] & 0xff) | (b[3] & 0xff) << 8) << 16;
 173   }
 174
 175   /**
 176    * Read an unsigned short in little endian byte order from the given
 177    * byte buffer at the given offset.
 178    *
 179    * @param b the byte array to read from.
 180    * @param off the offset to read from.
 181    * @return The value read.
 182    */
 183   private int readLeShort(byte[] b, int off)
 184   {
 185     return (b[off] & 0xff) | (b[off+1] & 0xff) << 8;
 186   }
 187
 188   /**
 189    * Read an int in little endian byte order from the given
 190    * byte buffer at the given offset.
 191    *
 192    * @param b the byte array to read from.
 193    * @param off the offset to read from.
 194    * @return The value read.
 195    */
 196   private int readLeInt(byte[] b, int off)
 197   {
 198     return ((b[off] & 0xff) | (b[off+1] & 0xff) << 8)
 199             | ((b[off+2] & 0xff) | (b[off+3] & 0xff) << 8) << 16;
 200   }
 201
 202
 203   /**
 204    * Read the central directory of a zip file and fill the entries
 205    * array.  This is called exactly once when first needed. It is called
 206    * while holding the lock on <code>raf</code>.
 207    *
 208    * @exception IOException if a i/o error occured.
 209    * @exception ZipException if the central directory is malformed
 210    */
 211   private void readEntries() throws ZipException, IOException
 212   {
 213     /* Search for the End Of Central Directory.  When a zip comment is
 214      * present the directory may start earlier.
 215      * FIXME: This searches the whole file in a very slow manner if the
 216      * file isn't a zip file.
 217      */
 218     long pos = raf.length() - ENDHDR;
 219     byte[] ebs  = new byte[CENHDR];
 220
 221     do
 222       {
 223         if (pos < 0)
 224           throw new ZipException
 225             ("central directory not found, probably not a zip file: " + name);
 226         raf.seek(pos--);
 227       }
 228     while (readLeInt(raf, ebs) != ENDSIG);
 229
 230     if (raf.skipBytes(ENDTOT - ENDNRD) != ENDTOT - ENDNRD)
 231       throw new EOFException(name);
 232     int count = readLeShort(raf, ebs);
 233     if (raf.skipBytes(ENDOFF - ENDSIZ) != ENDOFF - ENDSIZ)
 234       throw new EOFException(name);
 235     int centralOffset = readLeInt(raf, ebs);
 236
 237     entries = new HashMap(count+count/2);
 238     raf.seek(centralOffset);
 239
 240     byte[] buffer = new byte[16];
 241     for (int i = 0; i < count; i++)
 242       {
 243         raf.readFully(ebs);
 244         if (readLeInt(ebs, 0) != CENSIG)
 245           throw new ZipException("Wrong Central Directory signature: " + name);
 246
 247         int method = readLeShort(ebs, CENHOW);
 248         int dostime = readLeInt(ebs, CENTIM);
 249         int crc = readLeInt(ebs, CENCRC);
 250         int csize = readLeInt(ebs, CENSIZ);
 251         int size = readLeInt(ebs, CENLEN);
 252         int nameLen = readLeShort(ebs, CENNAM);
 253         int extraLen = readLeShort(ebs, CENEXT);
 254         int commentLen = readLeShort(ebs, CENCOM);
 255
 256         int offset = readLeInt(ebs, CENOFF);
 257
 258         int needBuffer = Math.max(nameLen, commentLen);
 259         if (buffer.length < needBuffer)
 260           buffer = new byte[needBuffer];
 261
 262         raf.readFully(buffer, 0, nameLen);
 263         String name = new String(buffer, 0, 0, nameLen);
 264
 265         ZipEntry entry = new ZipEntry(name);
 266         entry.setMethod(method);
 267         entry.setCrc(crc & 0xffffffffL);
 268         entry.setSize(size & 0xffffffffL);
 269         entry.setCompressedSize(csize & 0xffffffffL);
 270         entry.setDOSTime(dostime);
 271         if (extraLen > 0)
 272           {
 273             byte[] extra = new byte[extraLen];
 274             raf.readFully(extra);
 275             entry.setExtra(extra);
 276           }
 277         if (commentLen > 0)
 278           {
 279             raf.readFully(buffer, 0, commentLen);
 280             entry.setComment(new String(buffer, 0, commentLen));
 281           }
 282         entry.offset = offset;
 283         entries.put(name, entry);
 284       }
 285   }
 286
 287   /**
 288    * Closes the ZipFile.  This also closes all input streams given by
 289    * this class.  After this is called, no further method should be
 290    * called.
 291    *
 292    * @exception IOException if a i/o error occured.
 293    */
 294   public void close() throws IOException
 295   {
 296     synchronized (raf)
 297       {
 298         closed = true;
 299         entries = null;
 300         raf.close();
 301       }
 302   }
 303
 304   /**
 305    * Calls the <code>close()</code> method when this ZipFile has not yet
 306    * been explicitly closed.
 307    */
 308   protected void finalize() throws IOException
 309   {
 310     if (!closed && raf != null) close();
 311   }
 312
 313   /**
 314    * Returns an enumeration of all Zip entries in this Zip file.
 315    */
 316   public Enumeration entries()
 317   {
 318     try
 319       {
 320         return new ZipEntryEnumeration(getEntries().values().iterator());
 321       }
 322     catch (IOException ioe)
 323       {
 324         return null;
 325       }
 326   }
 327
 328   /**
 329    * Checks that the ZipFile is still open and reads entries when necessary.
 330    *
 331    * @exception IllegalStateException when the ZipFile has already been closed.
 332    * @exception IOEexception when the entries could not be read.
 333    */
 334   private HashMap getEntries() throws IOException
 335   {
 336     synchronized(raf)
 337       {
 338         if (closed)
 339           throw new IllegalStateException("ZipFile has closed: " + name);
 340
 341         if (entries == null)
 342           readEntries();
 343
 344         return entries;
 345       }
 346   }
 347
 348   /**
 349    * Searches for a zip entry in this archive with the given name.
 350    *
 351    * @param the name. May contain directory components separated by
 352    * slashes ('/').
 353    * @return the zip entry, or null if no entry with that name exists.
 354    */
 355   public ZipEntry getEntry(String name)
 356   {
 357     try
 358       {
 359         HashMap entries = getEntries();
 360         ZipEntry entry = (ZipEntry) entries.get(name);
 361         return entry != null ? (ZipEntry) entry.clone() : null;
 362       }
 363     catch (IOException ioe)
 364       {
 365         return null;
 366       }
 367   }
 368
 369
 370   //access should be protected by synchronized(raf)
 371   private byte[] locBuf = new byte[LOCHDR];
 372
 373   /**
 374    * Checks, if the local header of the entry at index i matches the
 375    * central directory, and returns the offset to the data.
 376    *
 377    * @param entry to check.
 378    * @return the start offset of the (compressed) data.
 379    *
 380    * @exception IOException if a i/o error occured.
 381    * @exception ZipException if the local header doesn't match the
 382    * central directory header
 383    */
 384   private long checkLocalHeader(ZipEntry entry) throws IOException
 385   {
 386     synchronized (raf)
 387       {
 388         raf.seek(entry.offset);
 389         raf.readFully(locBuf);
 390
 391         if (readLeInt(locBuf, 0) != LOCSIG)
 392           throw new ZipException("Wrong Local header signature: " + name);
 393
 394         if (entry.getMethod() != readLeShort(locBuf, LOCHOW))
 395           throw new ZipException("Compression method mismatch: " + name);
 396
 397         if (entry.getName().length() != readLeShort(locBuf, LOCNAM))
 398           throw new ZipException("file name length mismatch: " + name);
 399
 400         int extraLen = entry.getName().length() + readLeShort(locBuf, LOCEXT);
 401         return entry.offset + LOCHDR + extraLen;
 402       }
 403   }
 404
 405   /**
 406    * Creates an input stream reading the given zip entry as
 407    * uncompressed data.  Normally zip entry should be an entry
 408    * returned by getEntry() or entries().
 409    *
 410    * This implementation returns null if the requested entry does not
 411    * exist.  This decision is not obviously correct, however, it does
 412    * appear to mirror Sun's implementation, and it is consistant with
 413    * their javadoc.  On the other hand, the old JCL book, 2nd Edition,
 414    * claims that this should return a "non-null ZIP entry".  We have
 415    * chosen for now ignore the old book, as modern versions of Ant (an
 416    * important application) depend on this behaviour.  See discussion
 417    * in this thread:
 418    * http://gcc.gnu.org/ml/java-patches/2004-q2/msg00602.html
 419    *
 420    * @param entry the entry to create an InputStream for.
 421    * @return the input stream, or null if the requested entry does not exist.
 422    *
 423    * @exception IOException if a i/o error occured.
 424    * @exception ZipException if the Zip archive is malformed.
 425    */
 426   public InputStream getInputStream(ZipEntry entry) throws IOException
 427   {
 428     HashMap entries = getEntries();
 429     String name = entry.getName();
 430     ZipEntry zipEntry = (ZipEntry) entries.get(name);
 431     if (zipEntry == null)
 432       return null;
 433
 434     long start = checkLocalHeader(zipEntry);
 435     int method = zipEntry.getMethod();
 436     InputStream is = new BufferedInputStream(new PartialInputStream
 437       (raf, start, zipEntry.getCompressedSize()));
 438     switch (method)
 439       {
 440       case ZipOutputStream.STORED:
 441         return is;
 442       case ZipOutputStream.DEFLATED:
 443         return new InflaterInputStream(is, new Inflater(true));
 444       default:
 445         throw new ZipException("Unknown compression method " + method);
 446       }
 447   }
 448
 449   /**
 450    * Returns the (path) name of this zip file.
 451    */
 452   public String getName()
 453   {
 454     return name;
 455   }
 456
 457   /**
 458    * Returns the number of entries in this zip file.
 459    */
 460   public int size()
 461   {
 462     try
 463       {
 464         return getEntries().size();
 465       }
 466     catch (IOException ioe)
 467       {
 468         return 0;
 469       }
 470   }
 471
 472   private static class ZipEntryEnumeration implements Enumeration
 473   {
 474     private final Iterator elements;
 475
 476     public ZipEntryEnumeration(Iterator elements)
 477     {
 478       this.elements = elements;
 479     }
 480
 481     public boolean hasMoreElements()
 482     {
 483       return elements.hasNext();
 484     }
 485
 486     public Object nextElement()
 487     {
 488       /* We return a clone, just to be safe that the user doesn't
 489        * change the entry.
 490        */
 491       return ((ZipEntry)elements.next()).clone();
 492     }
 493   }
 494
 495   private static class PartialInputStream extends InputStream
 496   {
 497     private final RandomAccessFile raf;
 498     long filepos, end;
 499
 500     public PartialInputStream(RandomAccessFile raf, long start, long len)
 501     {
 502       this.raf = raf;
 503       filepos = start;
 504       end = start + len;
 505     }
 506
 507     public int available()
 508     {
 509       long amount = end - filepos;
 510       if (amount > Integer.MAX_VALUE)
 511         return Integer.MAX_VALUE;
 512       return (int) amount;
 513     }
 514
 515     public int read() throws IOException
 516     {
 517       if (filepos == end)
 518         return -1;
 519       synchronized (raf)
 520         {
 521           raf.seek(filepos++);
 522           return raf.read();
 523         }
 524     }
 525
 526     public int read(byte[] b, int off, int len) throws IOException
 527     {
 528       if (len > end - filepos)
 529         {
 530           len = (int) (end - filepos);
 531           if (len == 0)
 532             return -1;
 533         }
 534       synchronized (raf)
 535         {
 536           raf.seek(filepos);
 537           int count = raf.read(b, off, len);
 538           if (count > 0)
 539             filepos += len;
 540           return count;
 541         }
 542     }
 543
 544     public long skip(long amount)
 545     {
 546       if (amount < 0)
 547         throw new IllegalArgumentException();
 548       if (amount > end - filepos)
 549         amount = end - filepos;
 550       filepos += amount;
 551       return amount;
 552     }
 553   }
 554 }