ZipInputStream.java 9.91 KB
Newer Older
Tom Tromey committed
1
/* ZipInputStream.java --
Tom Tromey committed
2
   Copyright (C) 2001, 2002, 2003, 2004, 2005  Free Software Foundation, Inc.
Tom Tromey committed
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */


package java.util.zip;

import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
Tom Tromey committed
44
import java.io.UnsupportedEncodingException;
Tom Tromey committed
45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

/**
 * This is a FilterInputStream that reads the files in an zip archive
 * one after another.  It has a special method to get the zip entry of
 * the next file.  The zip entry contains information about the file name
 * size, compressed size, CRC, etc.
 *
 * It includes support for STORED and DEFLATED entries.
 *
 * @author Jochen Hoenicke
 */
public class ZipInputStream extends InflaterInputStream implements ZipConstants
{
  private CRC32 crc = new CRC32();
  private ZipEntry entry = null;

  private int csize;
  private int size;
  private int method;
  private int flags;
  private int avail;
  private boolean entryAtEOF;

  /**
   * Creates a new Zip input stream, reading a zip archive.
   */
  public ZipInputStream(InputStream in)
  {
    super(in, new Inflater(true));
  }

  private void fillBuf() throws IOException
  {
    avail = len = in.read(buf, 0, buf.length);
  }

  private int readBuf(byte[] out, int offset, int length) throws IOException
  {
    if (avail <= 0)
      {
85 86 87
        fillBuf();
        if (avail <= 0)
          return -1;
Tom Tromey committed
88 89 90 91 92 93 94
      }
    if (length > avail)
      length = avail;
    System.arraycopy(buf, len - avail, out, offset, length);
    avail -= length;
    return length;
  }
95

Tom Tromey committed
96 97 98 99 100 101
  private void readFully(byte[] out) throws IOException
  {
    int off = 0;
    int len = out.length;
    while (len > 0)
      {
102 103 104 105 106
        int count = readBuf(out, off, len);
        if (count == -1)
          throw new EOFException();
        off += count;
        len -= count;
Tom Tromey committed
107 108
      }
  }
109

Tom Tromey committed
110 111 112 113
  private int readLeByte() throws IOException
  {
    if (avail <= 0)
      {
114 115 116
        fillBuf();
        if (avail <= 0)
          throw new ZipException("EOF in header");
Tom Tromey committed
117 118 119 120 121 122 123
      }
    return buf[len - avail--] & 0xff;
  }

  /**
   * Read an unsigned short in little endian byte order.
   */
124
  private int readLeShort() throws IOException
Tom Tromey committed
125 126 127 128 129 130 131
  {
    return readLeByte() | (readLeByte() << 8);
  }

  /**
   * Read an int in little endian byte order.
   */
132
  private int readLeInt() throws IOException
Tom Tromey committed
133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150
  {
    return readLeShort() | (readLeShort() << 16);
  }

  /**
   * Open the next entry from the zip archive, and return its description.
   * If the previous entry wasn't closed, this method will close it.
   */
  public ZipEntry getNextEntry() throws IOException
  {
    if (crc == null)
      throw new IOException("Stream closed.");
    if (entry != null)
      closeEntry();

    int header = readLeInt();
    if (header == CENSIG)
      {
151 152 153
        /* Central Header reached. */
        close();
        return null;
Tom Tromey committed
154 155 156
      }
    if (header != LOCSIG)
      throw new ZipException("Wrong Local header signature: "
157
                             + Integer.toHexString(header));
Tom Tromey committed
158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
    /* skip version */
    readLeShort();
    flags = readLeShort();
    method = readLeShort();
    int dostime = readLeInt();
    int crc = readLeInt();
    csize = readLeInt();
    size = readLeInt();
    int nameLen = readLeShort();
    int extraLen = readLeShort();

    if (method == ZipOutputStream.STORED && csize != size)
      throw new ZipException("Stored, but compressed != uncompressed");


    byte[] buffer = new byte[nameLen];
    readFully(buffer);
Tom Tromey committed
175 176 177
    String name;
    try
      {
178
        name = new String(buffer, "UTF-8");
Tom Tromey committed
179 180 181
      }
    catch (UnsupportedEncodingException uee)
      {
182
        throw new AssertionError(uee);
Tom Tromey committed
183
      }
184

Tom Tromey committed
185 186 187 188 189
    entry = createZipEntry(name);
    entryAtEOF = false;
    entry.setMethod(method);
    if ((flags & 8) == 0)
      {
190 191 192
        entry.setCrc(crc & 0xffffffffL);
        entry.setSize(size & 0xffffffffL);
        entry.setCompressedSize(csize & 0xffffffffL);
Tom Tromey committed
193 194 195 196
      }
    entry.setDOSTime(dostime);
    if (extraLen > 0)
      {
197 198 199
        byte[] extra = new byte[extraLen];
        readFully(extra);
        entry.setExtra(extra);
Tom Tromey committed
200 201 202 203
      }

    if (method == ZipOutputStream.DEFLATED && avail > 0)
      {
204 205 206 207
        System.arraycopy(buf, len - avail, buf, 0, avail);
        len = avail;
        avail = 0;
        inf.setInput(buf, 0, len);
Tom Tromey committed
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234
      }
    return entry;
  }

  private void readDataDescr() throws IOException
  {
    if (readLeInt() != EXTSIG)
      throw new ZipException("Data descriptor signature not found");
    entry.setCrc(readLeInt() & 0xffffffffL);
    csize = readLeInt();
    size = readLeInt();
    entry.setSize(size & 0xffffffffL);
    entry.setCompressedSize(csize & 0xffffffffL);
  }

  /**
   * Closes the current zip entry and moves to the next one.
   */
  public void closeEntry() throws IOException
  {
    if (crc == null)
      throw new IOException("Stream closed.");
    if (entry == null)
      return;

    if (method == ZipOutputStream.DEFLATED)
      {
235 236 237 238 239 240 241 242 243 244 245 246
        if ((flags & 8) != 0)
          {
            /* We don't know how much we must skip, read until end. */
            byte[] tmp = new byte[2048];
            while (read(tmp) > 0)
              ;

            /* read will close this entry */
            return;
          }
        csize -= inf.getTotalIn();
        avail = inf.getRemaining();
Tom Tromey committed
247 248 249 250 251 252
      }

    if (avail > csize && csize >= 0)
      avail -= csize;
    else
      {
253 254 255 256 257 258 259 260 261
        csize -= avail;
        avail = 0;
        while (csize != 0)
          {
            long skipped = in.skip(csize & 0xffffffffL);
            if (skipped <= 0)
              throw new ZipException("zip archive ends early.");
            csize -= skipped;
          }
Tom Tromey committed
262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309
      }

    size = 0;
    crc.reset();
    if (method == ZipOutputStream.DEFLATED)
      inf.reset();
    entry = null;
    entryAtEOF = true;
  }

  public int available() throws IOException
  {
    return entryAtEOF ? 0 : 1;
  }

  /**
   * Reads a byte from the current zip entry.
   * @return the byte or -1 on EOF.
   * @exception IOException if a i/o error occured.
   * @exception ZipException if the deflated stream is corrupted.
   */
  public int read() throws IOException
  {
    byte[] b = new byte[1];
    if (read(b, 0, 1) <= 0)
      return -1;
    return b[0] & 0xff;
  }

  /**
   * Reads a block of bytes from the current zip entry.
   * @return the number of bytes read (may be smaller, even before
   * EOF), or -1 on EOF.
   * @exception IOException if a i/o error occured.
   * @exception ZipException if the deflated stream is corrupted.
   */
  public int read(byte[] b, int off, int len) throws IOException
  {
    if (len == 0)
      return 0;
    if (crc == null)
      throw new IOException("Stream closed.");
    if (entry == null)
      return -1;
    boolean finished = false;
    switch (method)
      {
      case ZipOutputStream.DEFLATED:
310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326
        len = super.read(b, off, len);
        if (len < 0)
          {
            if (!inf.finished())
              throw new ZipException("Inflater not finished!?");
            avail = inf.getRemaining();
            if ((flags & 8) != 0)
              readDataDescr();

            if (inf.getTotalIn() != csize
                || inf.getTotalOut() != size)
              throw new ZipException("size mismatch: "+csize+";"+size+" <-> "+inf.getTotalIn()+";"+inf.getTotalOut());
            inf.reset();
            finished = true;
          }
        break;

Tom Tromey committed
327 328
      case ZipOutputStream.STORED:

329 330 331 332 333 334 335 336 337 338 339 340 341 342 343
        if (len > csize && csize >= 0)
          len = csize;

        len = readBuf(b, off, len);
        if (len > 0)
          {
            csize -= len;
            size -= len;
          }

        if (csize == 0)
          finished = true;
        else if (len < 0)
          throw new ZipException("EOF in stored block");
        break;
Tom Tromey committed
344 345 346 347 348 349 350
      }

    if (len > 0)
      crc.update(b, off, len);

    if (finished)
      {
351 352 353 354 355
        if ((crc.getValue() & 0xffffffffL) != entry.getCrc())
          throw new ZipException("CRC mismatch");
        crc.reset();
        entry = null;
        entryAtEOF = true;
Tom Tromey committed
356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376
      }
    return len;
  }

  /**
   * Closes the zip file.
   * @exception IOException if a i/o error occured.
   */
  public void close() throws IOException
  {
    super.close();
    crc = null;
    entry = null;
    entryAtEOF = true;
  }

  /**
   * Creates a new zip entry for the given name.  This is equivalent
   * to new ZipEntry(name).
   * @param name the name of the zip entry.
   */
377
  protected ZipEntry createZipEntry(String name)
Tom Tromey committed
378 379 380 381
  {
    return new ZipEntry(name);
  }
}