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
26package java.util.zip;
27
28import java.io.FilterOutputStream;
29import java.io.IOException;
30import 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@tribble.com)
38 *
39 * @see InflaterInputStream
40 * @see DeflaterInputStream
41 * @see DeflaterOutputStream
42 */
43
44public 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