1 /* 2 * Copyright (c) 2006, 2013, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package java.util.zip; 27 28 import java.io.FilterOutputStream; 29 import java.io.IOException; 30 import java.io.OutputStream; 31 32 /** 33 * Implements an output stream filter for uncompressing data stored in the 34 * "deflate" compression format. 35 * 36 * @since 1.6 37 * @author David R Tribble (david (at) tribble.com) 38 * 39 * @see InflaterInputStream 40 * @see DeflaterInputStream 41 * @see DeflaterOutputStream 42 */ 43 44 public class InflaterOutputStream extends FilterOutputStream { 45 /** Decompressor for this stream. */ 46 protected final Inflater inf; 47 48 /** Output buffer for writing uncompressed data. */ 49 protected final byte[] buf; 50 51 /** Temporary write buffer. */ 52 private final byte[] wbuf = new byte[1]; 53 54 /** Default decompressor is used. */ 55 private boolean usesDefaultInflater = false; 56 57 /** true iff {@link #close()} has been called. */ 58 private boolean closed = false; 59 60 /** 61 * Checks to make sure that this stream has not been closed. 62 */ 63 private void ensureOpen() throws IOException { 64 if (closed) { 65 throw new IOException("Stream closed"); 66 } 67 } 68 69 /** 70 * Creates a new output stream with a default decompressor and buffer 71 * size. 72 * 73 * @param out output stream to write the uncompressed data to 74 * @throws NullPointerException if {@code out} is null 75 */ 76 public InflaterOutputStream(OutputStream out) { 77 this(out, new Inflater()); 78 usesDefaultInflater = true; 79 } 80 81 /** 82 * Creates a new output stream with the specified decompressor and a 83 * default buffer size. 84 * 85 * @param out output stream to write the uncompressed data to 86 * @param infl decompressor ("inflater") for this stream 87 * @throws NullPointerException if {@code out} or {@code infl} is null 88 */ 89 public InflaterOutputStream(OutputStream out, Inflater infl) { 90 this(out, infl, 512); 91 } 92 93 /** 94 * Creates a new output stream with the specified decompressor and 95 * buffer size. 96 * 97 * @param out output stream to write the uncompressed data to 98 * @param infl decompressor ("inflater") for this stream 99 * @param bufLen decompression buffer size 100 * @throws IllegalArgumentException if {@code bufLen <= 0} 101 * @throws NullPointerException if {@code out} or {@code infl} is null 102 */ 103 public InflaterOutputStream(OutputStream out, Inflater infl, int bufLen) { 104 super(out); 105 106 // Sanity checks 107 if (out == null) 108 throw new NullPointerException("Null output"); 109 if (infl == null) 110 throw new NullPointerException("Null inflater"); 111 if (bufLen <= 0) 112 throw new IllegalArgumentException("Buffer size < 1"); 113 114 // Initialize 115 inf = infl; 116 buf = new byte[bufLen]; 117 } 118 119 /** 120 * Writes any remaining uncompressed data to the output stream and closes 121 * the underlying output stream. 122 * 123 * @throws IOException if an I/O error occurs 124 */ 125 public void close() throws IOException { 126 if (!closed) { 127 // Complete the uncompressed output 128 try { 129 finish(); 130 } finally { 131 out.close(); 132 closed = true; 133 } 134 } 135 } 136 137 /** 138 * Flushes this output stream, forcing any pending buffered output bytes to be 139 * written. 140 * 141 * @throws IOException if an I/O error occurs or this stream is already 142 * closed 143 */ 144 public void flush() throws IOException { 145 ensureOpen(); 146 147 // Finish decompressing and writing pending output data 148 if (!inf.finished()) { 149 try { 150 while (!inf.finished() && !inf.needsInput()) { 151 int n; 152 153 // Decompress pending output data 154 n = inf.inflate(buf, 0, buf.length); 155 if (n < 1) { 156 break; 157 } 158 159 // Write the uncompressed output data block 160 out.write(buf, 0, n); 161 } 162 super.flush(); 163 } catch (DataFormatException ex) { 164 // Improperly formatted compressed (ZIP) data 165 String msg = ex.getMessage(); 166 if (msg == null) { 167 msg = "Invalid ZLIB data format"; 168 } 169 throw new ZipException(msg); 170 } 171 } 172 } 173 174 /** 175 * Finishes writing uncompressed data to the output stream without closing 176 * the underlying stream. Use this method when applying multiple filters in 177 * succession to the same output stream. 178 * 179 * @throws IOException if an I/O error occurs or this stream is already 180 * closed 181 */ 182 public void finish() throws IOException { 183 ensureOpen(); 184 185 // Finish decompressing and writing pending output data 186 flush(); 187 if (usesDefaultInflater) { 188 inf.end(); 189 } 190 } 191 192 /** 193 * Writes a byte to the uncompressed output stream. 194 * 195 * @param b a single byte of compressed data to decompress and write to 196 * the output stream 197 * @throws IOException if an I/O error occurs or this stream is already 198 * closed 199 * @throws ZipException if a compression (ZIP) format error occurs 200 */ 201 public void write(int b) throws IOException { 202 // Write a single byte of data 203 wbuf[0] = (byte) b; 204 write(wbuf, 0, 1); 205 } 206 207 /** 208 * Writes an array of bytes to the uncompressed output stream. 209 * 210 * @param b buffer containing compressed data to decompress and write to 211 * the output stream 212 * @param off starting offset of the compressed data within {@code b} 213 * @param len number of bytes to decompress from {@code b} 214 * @throws IndexOutOfBoundsException if {@code off < 0}, or if 215 * {@code len < 0}, or if {@code len > b.length - off} 216 * @throws IOException if an I/O error occurs or this stream is already 217 * closed 218 * @throws NullPointerException if {@code b} is null 219 * @throws ZipException if a compression (ZIP) format error occurs 220 */ 221 public void write(byte[] b, int off, int len) throws IOException { 222 // Sanity checks 223 ensureOpen(); 224 if (b == null) { 225 throw new NullPointerException("Null buffer for read"); 226 } else if (off < 0 || len < 0 || len > b.length - off) { 227 throw new IndexOutOfBoundsException(); 228 } else if (len == 0) { 229 return; 230 } 231 232 // Write uncompressed data to the output stream 233 try { 234 for (;;) { 235 int n; 236 237 // Fill the decompressor buffer with output data 238 if (inf.needsInput()) { 239 int part; 240 241 if (len < 1) { 242 break; 243 } 244 245 part = (len < 512 ? len : 512); 246 inf.setInput(b, off, part); 247 off += part; 248 len -= part; 249 } 250 251 // Decompress and write blocks of output data 252 do { 253 n = inf.inflate(buf, 0, buf.length); 254 if (n > 0) { 255 out.write(buf, 0, n); 256 } 257 } while (n > 0); 258 259 // Check the decompressor 260 if (inf.finished()) { 261 break; 262 } 263 if (inf.needsDictionary()) { 264 throw new ZipException("ZLIB dictionary missing"); 265 } 266 } 267 } catch (DataFormatException ex) { 268 // Improperly formatted compressed (ZIP) data 269 String msg = ex.getMessage(); 270 if (msg == null) { 271 msg = "Invalid ZLIB data format"; 272 } 273 throw new ZipException(msg); 274 } 275 } 276 } 277
