libjava/java/util/zip/ZipInputStream.java

/* ZipInputStream.java - Input filter for reading 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.*;

/**
 * @author Per Bothner
 * @date May 1999.
 */

/*
 * Written using on-line Java Platform 1.2 API Specification, as well
 * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998).
 * Status:  Quite incomplete, but can read uncompressed .zip archives.
 */

// We do not calculate the CRC and compare it with the specified value;
// we probably should.  FIXME.
   

public class ZipInputStream extends InflaterInputStream implements ZipConstants
{
  public ZipInputStream (InputStream in)
  {
    super (in, new Inflater (true));
  }

  public ZipEntry getNextEntry () throws IOException
  {
    if (closed)
      throw new IOException ("stream closed");
    if (current != null)
      closeEntry();
    if (in.read() != 'P'
	|| in.read() != 'K')
      return null;
    int code = in.read();
    while (code == '\001')
      {
	code = in.read();
	if (code != '\002')
	  return null;
	in.skip(16);
	int size = read4();
	in.skip(4);
	int fname_length = readu2();
	int extra_length = readu2();
	int fcomment_length = readu2();
	// `12' is the number of bytes between the comment length
	// field and the end of the fixed part of the header:
	// 2 bytes for `disk number start'
	// 2 bytes for `internal file attributes'
	// 4 bytes for `external file attributes'
	// 4 bytes for `relative offset of local header'
	in.skip(12 + fname_length + extra_length + fcomment_length);
	if (in.read() != 'P' || in.read() != 'K')
	  return null;
	code = in.read();
      }
    if (code == '\005')
      {
	if (in.read() != '\006')
	  return null;
	in.skip(16);
	int comment_size = readu2();
	in.skip(comment_size);
	if (in.read() != 'P' || in.read() != 'K')
	  return null;
	code = in.read();
      }
    if (code != '\003'
	|| in.read() != '\004')
      return null;
    int ex_version = readu2();
    current_flags = readu2();
    int method = readu2();
    int modtime = readu2();
    int moddate = readu2();
    int crc = read4();
    int compressedSize = read4();
    int uncompressedSize = read4();
    int filenameLength = readu2();
    int extraLength = readu2();
    byte[] bname = new byte[filenameLength];
    readFully(bname);
    ZipEntry entry = createZipEntry(new String(bname, "8859_1"));
    if (extraLength > 0)
      {
	byte[] bextra = new byte[extraLength];
	readFully(bextra);
	entry.extra = bextra;
      }
    entry.compressedSize = compressedSize;
    entry.size = uncompressedSize;
    entry.crc = (long) crc & 0xffffffffL;
    entry.method = method;
    entry.time = ZipEntry.timeFromDOS(moddate, modtime);
    current = entry;
    avail = uncompressedSize;
    compressed_bytes = compressedSize;
    return entry;
  }

  // We override fill to let us control how much data gets read from
  // the underlying input stream.  This lets us avoid having to push
  // back data.
  protected void fill () throws IOException
  {
    if (closed)
      throw new IOException ("stream closed");
    int count = buf.length;
    if (count > compressed_bytes)
      count = compressed_bytes;
    len = in.read(buf, 0, count);
    if (len != -1)
      {
	compressed_bytes -= len;
	inf.setInput(buf, 0, len);
      }
  }

  /**
   * Creates a new ZipEntry with the given name.
   * Used by ZipInputStream when normally <code>new ZipEntry (name)</code>
   * would be called. This gives subclasses such as JarInputStream a change
   * to override this method and add aditional information to the ZipEntry
   * (subclass).
   */
  protected ZipEntry createZipEntry (String name)
  {
    return new ZipEntry (name);
  }

  public int read (byte[] b, int off, int len)  throws IOException
  {
    if (closed)
      throw new IOException ("stream closed");
    if (len > avail)
      len = avail;
    int count;
    if (current.method == Deflater.DEFLATED)
      count = super.read(b, off, len);
    else
      count = in.read(b, off, len);
    if (count == -1 || avail == 0)
      {
	inf.reset();
	count = -1;
      }
    else
      avail -= count;
    return count;
  }

  public long skip (long n)  throws IOException
  {
    if (closed)
      throw new IOException ("stream closed");
    if (n > avail)
      n = avail;
    long count;
    if (current.method == Deflater.DEFLATED)
      count = super.skip(n);
    else
      count = in.skip(n);
    avail = avail - (int) count;
    return count;
  }

  /**
   * Returns 0 if the ZipInputStream is closed and 1 otherwise.
   *
   * @since 1.2
   */
  public int available()
  {
    return closed ? 0 : 1;
  }

  private void readFully (byte[] b)  throws IOException
  {
    int off = 0;
    int len = b.length;
    while (len > 0)
      {
	int count = in.read(b, off, len);
	if (count <= 0)
	  throw new EOFException(".zip archive ended prematurely");
	off += count;
	len -= count;
      }
  }

  private int readu2 ()  throws IOException
  {
    int byte0 = in.read();
    int byte1 = in.read();
    if (byte0 < 0 || byte1 < 0)
      throw new EOFException(".zip archive ended prematurely");
    return ((byte1 & 0xFF) << 8) | (byte0 & 0xFF);
  }

  private int read4 () throws IOException
  {
    int byte0 = in.read();
    int byte1 = in.read();
    int byte2 = in.read();
    int byte3 = in.read();
    if (byte3 < 0)
      throw new EOFException(".zip archive ended prematurely");
    return ((byte3 & 0xFF) << 24) + ((byte2 & 0xFF) << 16)
      + ((byte1 & 0xFF) << 8) + (byte0 & 0xFF);
  }

  public void closeEntry ()  throws IOException
  {
    if (current != null)
      {
	if (avail > 0)
	  skip (avail);
	if ((current_flags & 8) != 0)
	  {
	    int sig = read4();
	    if (sig != 0x04034b50)
	      throw new ZipException("bad/missing magic number at end of .zip entry");
	    int crc = read4();
	    int compressedSize = read4();
	    int uncompressedSize = read4();
	    if (current.compressedSize != compressedSize
		|| current.size != uncompressedSize
		|| current.crc != crc)
	      throw new ZipException("bad data descriptor at end of .zip entry");
	  }
	current = null;
	avail = 0;
      }
  }

  /**
   * Closes this InflaterInputStream.
   *
   * @since 1.2
   */
  public void close ()  throws IOException
  {
    current = null;
    closed = true;
    super.close();
  }

  private ZipEntry current;
  private int current_flags;
  // Number of uncompressed bytes to be read.
  private int avail;
  // Number of bytes we can read from underlying stream.
  private int compressed_bytes;
  // Is this ZipInputStream closed? Set by the close() method.
  private boolean closed = false;
}