| Frames | No Frames |
1: /* InflaterInputStream.java - Input stream filter for decompressing 2: Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2006 3: Free Software Foundation, Inc. 4: 5: This file is part of GNU Classpath. 6: 7: GNU Classpath is free software; you can redistribute it and/or modify 8: it under the terms of the GNU General Public License as published by 9: the Free Software Foundation; either version 2, or (at your option) 10: any later version. 11: 12: GNU Classpath is distributed in the hope that it will be useful, but 13: WITHOUT ANY WARRANTY; without even the implied warranty of 14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15: General Public License for more details. 16: 17: You should have received a copy of the GNU General Public License 18: along with GNU Classpath; see the file COPYING. If not, write to the 19: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 20: 02110-1301 USA. 21: 22: Linking this library statically or dynamically with other modules is 23: making a combined work based on this library. Thus, the terms and 24: conditions of the GNU General Public License cover the whole 25: combination. 26: 27: As a special exception, the copyright holders of this library give you 28: permission to link this library with independent modules to produce an 29: executable, regardless of the license terms of these independent 30: modules, and to copy and distribute the resulting executable under 31: terms of your choice, provided that you also meet, for each linked 32: independent module, the terms and conditions of the license of that 33: module. An independent module is a module which is not derived from 34: or based on this library. If you modify this library, you may extend 35: this exception to your version of the library, but you are not 36: obligated to do so. If you do not wish to do so, delete this 37: exception statement from your version. */ 38: 39: 40: package java.util.zip; 41: 42: import java.io.FilterInputStream; 43: import java.io.IOException; 44: import java.io.InputStream; 45: 46: /** 47: * This filter stream is used to decompress data compressed in the "deflate" 48: * format. The "deflate" format is described in RFC 1951. 49: * 50: * This stream may form the basis for other decompression filters, such 51: * as the <code>GZIPInputStream</code>. 52: * 53: * @author John Leuner 54: * @author Tom Tromey 55: * @since 1.1 56: */ 57: public class InflaterInputStream extends FilterInputStream 58: { 59: /** 60: * Decompressor for this filter 61: */ 62: protected Inflater inf; 63: 64: /** 65: * Byte array used as a buffer 66: */ 67: protected byte[] buf; 68: 69: /** 70: * Size of buffer 71: */ 72: protected int len; 73: 74: // We just use this if we are decoding one byte at a time with the 75: // read() call. 76: private byte[] onebytebuffer = new byte[1]; 77: 78: /** 79: * Create an InflaterInputStream with the default decompresseor 80: * and a default buffer size. 81: * 82: * @param in the InputStream to read bytes from 83: */ 84: public InflaterInputStream(InputStream in) 85: { 86: this(in, new Inflater(), 4096); 87: } 88: 89: /** 90: * Create an InflaterInputStream with the specified decompresseor 91: * and a default buffer size. 92: * 93: * @param in the InputStream to read bytes from 94: * @param inf the decompressor used to decompress data read from in 95: */ 96: public InflaterInputStream(InputStream in, Inflater inf) 97: { 98: this(in, inf, 4096); 99: } 100: 101: /** 102: * Create an InflaterInputStream with the specified decompresseor 103: * and a specified buffer size. 104: * 105: * @param in the InputStream to read bytes from 106: * @param inf the decompressor used to decompress data read from in 107: * @param size size of the buffer to use 108: */ 109: public InflaterInputStream(InputStream in, Inflater inf, int size) 110: { 111: super(in); 112: 113: if (in == null) 114: throw new NullPointerException("in may not be null"); 115: if (inf == null) 116: throw new NullPointerException("inf may not be null"); 117: if (size < 0) 118: throw new IllegalArgumentException("size may not be negative"); 119: 120: this.inf = inf; 121: this.buf = new byte [size]; 122: } 123: 124: /** 125: * Returns 0 once the end of the stream (EOF) has been reached. 126: * Otherwise returns 1. 127: */ 128: public int available() throws IOException 129: { 130: // According to the JDK 1.2 docs, this should only ever return 0 131: // or 1 and should not be relied upon by Java programs. 132: if (inf == null) 133: throw new IOException("stream closed"); 134: return inf.finished() ? 0 : 1; 135: } 136: 137: /** 138: * Closes the input stream 139: */ 140: public synchronized void close() throws IOException 141: { 142: if (in != null) 143: in.close(); 144: in = null; 145: } 146: 147: /** 148: * Fills the buffer with more data to decompress. 149: */ 150: protected void fill() throws IOException 151: { 152: if (in == null) 153: throw new ZipException ("InflaterInputStream is closed"); 154: 155: len = in.read(buf, 0, buf.length); 156: 157: if (len < 0) 158: throw new ZipException("Deflated stream ends early."); 159: 160: inf.setInput(buf, 0, len); 161: } 162: 163: /** 164: * Reads one byte of decompressed data. 165: * 166: * The byte is in the lower 8 bits of the int. 167: */ 168: public int read() throws IOException 169: { 170: int nread = read(onebytebuffer, 0, 1); 171: if (nread > 0) 172: return onebytebuffer[0] & 0xff; 173: return -1; 174: } 175: 176: /** 177: * Decompresses data into the byte array 178: * 179: * @param b the array to read and decompress data into 180: * @param off the offset indicating where the data should be placed 181: * @param len the number of bytes to decompress 182: */ 183: public int read(byte[] b, int off, int len) throws IOException 184: { 185: if (inf == null) 186: throw new IOException("stream closed"); 187: if (len == 0) 188: return 0; 189: if (inf.finished()) 190: return -1; 191: 192: int count = 0; 193: while (count == 0) 194: { 195: if (inf.needsInput()) 196: fill(); 197: 198: try 199: { 200: count = inf.inflate(b, off, len); 201: if (count == 0) 202: { 203: if (this.len == -1) 204: { 205: // Couldn't get any more data to feed to the Inflater 206: return -1; 207: } 208: if (inf.needsDictionary()) 209: throw new ZipException("Inflater needs Dictionary"); 210: } 211: } 212: catch (DataFormatException dfe) 213: { 214: throw new ZipException(dfe.getMessage()); 215: } 216: } 217: return count; 218: } 219: 220: /** 221: * Skip specified number of bytes of uncompressed data 222: * 223: * @param n number of bytes to skip 224: */ 225: public long skip(long n) throws IOException 226: { 227: if (inf == null) 228: throw new IOException("stream closed"); 229: if (n < 0) 230: throw new IllegalArgumentException(); 231: 232: if (n == 0) 233: return 0; 234: 235: int buflen = (int) Math.min(n, 2048); 236: byte[] tmpbuf = new byte[buflen]; 237: 238: long skipped = 0L; 239: while (n > 0L) 240: { 241: int numread = read(tmpbuf, 0, buflen); 242: if (numread <= 0) 243: break; 244: n -= numread; 245: skipped += numread; 246: buflen = (int) Math.min(n, 2048); 247: } 248: 249: return skipped; 250: } 251: 252: public boolean markSupported() 253: { 254: return false; 255: } 256: 257: public void mark(int readLimit) 258: { 259: } 260: 261: public void reset() throws IOException 262: { 263: throw new IOException("reset not supported"); 264: } 265: }