| /* |
| * Copyright (c) 2004, 2013, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code 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 |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| package sun.net.www.http; |
| |
| import java.io.*; |
| |
| /** |
| * OutputStream that sends the output to the underlying stream using chunked |
| * encoding as specified in RFC 2068. |
| */ |
| public class ChunkedOutputStream extends PrintStream { |
| |
| /* Default chunk size (including chunk header) if not specified */ |
| static final int DEFAULT_CHUNK_SIZE = 4096; |
| private static final byte[] CRLF = {'\r', '\n'}; |
| private static final int CRLF_SIZE = CRLF.length; |
| private static final byte[] FOOTER = CRLF; |
| private static final int FOOTER_SIZE = CRLF_SIZE; |
| private static final byte[] EMPTY_CHUNK_HEADER = getHeader(0); |
| private static final int EMPTY_CHUNK_HEADER_SIZE = getHeaderSize(0); |
| |
| /* internal buffer */ |
| private byte buf[]; |
| /* size of data (excluding footers and headers) already stored in buf */ |
| private int size; |
| /* current index in buf (i.e. buf[count] */ |
| private int count; |
| /* number of bytes to be filled up to complete a data chunk |
| * currently being built */ |
| private int spaceInCurrentChunk; |
| |
| /* underlying stream */ |
| private PrintStream out; |
| |
| /* the chunk size we use */ |
| private int preferredChunkDataSize; |
| private int preferedHeaderSize; |
| private int preferredChunkGrossSize; |
| /* header for a complete Chunk */ |
| private byte[] completeHeader; |
| |
| /* return the size of the header for a particular chunk size */ |
| private static int getHeaderSize(int size) { |
| return (Integer.toHexString(size)).length() + CRLF_SIZE; |
| } |
| |
| /* return a header for a particular chunk size */ |
| private static byte[] getHeader(int size){ |
| try { |
| String hexStr = Integer.toHexString(size); |
| byte[] hexBytes = hexStr.getBytes("US-ASCII"); |
| byte[] header = new byte[getHeaderSize(size)]; |
| for (int i=0; i<hexBytes.length; i++) |
| header[i] = hexBytes[i]; |
| header[hexBytes.length] = CRLF[0]; |
| header[hexBytes.length+1] = CRLF[1]; |
| return header; |
| } catch (java.io.UnsupportedEncodingException e) { |
| /* This should never happen */ |
| throw new InternalError(e.getMessage(), e); |
| } |
| } |
| |
| public ChunkedOutputStream(PrintStream o) { |
| this(o, DEFAULT_CHUNK_SIZE); |
| } |
| |
| public ChunkedOutputStream(PrintStream o, int size) { |
| super(o); |
| out = o; |
| |
| if (size <= 0) { |
| size = DEFAULT_CHUNK_SIZE; |
| } |
| |
| /* Adjust the size to cater for the chunk header - eg: if the |
| * preferred chunk size is 1k this means the chunk size should |
| * be 1017 bytes (differs by 7 from preferred size because of |
| * 3 bytes for chunk size in hex and CRLF (header) and CRLF (footer)). |
| * |
| * If headerSize(adjusted_size) is shorter then headerSize(size) |
| * then try to use the extra byte unless headerSize(adjusted_size+1) |
| * increases back to headerSize(size) |
| */ |
| if (size > 0) { |
| int adjusted_size = size - getHeaderSize(size) - FOOTER_SIZE; |
| if (getHeaderSize(adjusted_size+1) < getHeaderSize(size)){ |
| adjusted_size++; |
| } |
| size = adjusted_size; |
| } |
| |
| if (size > 0) { |
| preferredChunkDataSize = size; |
| } else { |
| preferredChunkDataSize = DEFAULT_CHUNK_SIZE - |
| getHeaderSize(DEFAULT_CHUNK_SIZE) - FOOTER_SIZE; |
| } |
| |
| preferedHeaderSize = getHeaderSize(preferredChunkDataSize); |
| preferredChunkGrossSize = preferedHeaderSize + preferredChunkDataSize |
| + FOOTER_SIZE; |
| completeHeader = getHeader(preferredChunkDataSize); |
| |
| /* start with an initial buffer */ |
| buf = new byte[preferredChunkGrossSize]; |
| reset(); |
| } |
| |
| /* |
| * Flush a buffered, completed chunk to an underlying stream. If the data in |
| * the buffer is insufficient to build up a chunk of "preferredChunkSize" |
| * then the data do not get flushed unless flushAll is true. If flushAll is |
| * true then the remaining data builds up a last chunk which size is smaller |
| * than preferredChunkSize, and then the last chunk gets flushed to |
| * underlying stream. If flushAll is true and there is no data in a buffer |
| * at all then an empty chunk (containing a header only) gets flushed to |
| * underlying stream. |
| */ |
| private void flush(boolean flushAll) { |
| if (spaceInCurrentChunk == 0) { |
| /* flush a completed chunk to underlying stream */ |
| out.write(buf, 0, preferredChunkGrossSize); |
| out.flush(); |
| reset(); |
| } else if (flushAll){ |
| /* complete the last chunk and flush it to underlying stream */ |
| if (size > 0){ |
| /* adjust a header start index in case the header of the last |
| * chunk is shorter then preferedHeaderSize */ |
| |
| int adjustedHeaderStartIndex = preferedHeaderSize - |
| getHeaderSize(size); |
| |
| /* write header */ |
| System.arraycopy(getHeader(size), 0, buf, |
| adjustedHeaderStartIndex, getHeaderSize(size)); |
| |
| /* write footer */ |
| buf[count++] = FOOTER[0]; |
| buf[count++] = FOOTER[1]; |
| |
| //send the last chunk to underlying stream |
| out.write(buf, adjustedHeaderStartIndex, count - adjustedHeaderStartIndex); |
| } else { |
| //send an empty chunk (containing just a header) to underlying stream |
| out.write(EMPTY_CHUNK_HEADER, 0, EMPTY_CHUNK_HEADER_SIZE); |
| } |
| |
| out.flush(); |
| reset(); |
| } |
| } |
| |
| @Override |
| public boolean checkError() { |
| return out.checkError(); |
| } |
| |
| /* Check that the output stream is still open */ |
| private void ensureOpen() { |
| if (out == null) |
| setError(); |
| } |
| |
| /* |
| * Writes data from b[] to an internal buffer and stores the data as data |
| * chunks of a following format: {Data length in Hex}{CRLF}{data}{CRLF} |
| * The size of the data is preferredChunkSize. As soon as a completed chunk |
| * is read from b[] a process of reading from b[] suspends, the chunk gets |
| * flushed to the underlying stream and then the reading process from b[] |
| * continues. When there is no more sufficient data in b[] to build up a |
| * chunk of preferredChunkSize size the data get stored as an incomplete |
| * chunk of a following format: {space for data length}{CRLF}{data} |
| * The size of the data is of course smaller than preferredChunkSize. |
| */ |
| @Override |
| public synchronized void write(byte b[], int off, int len) { |
| ensureOpen(); |
| if ((off < 0) || (off > b.length) || (len < 0) || |
| ((off + len) > b.length) || ((off + len) < 0)) { |
| throw new IndexOutOfBoundsException(); |
| } else if (len == 0) { |
| return; |
| } |
| |
| /* if b[] contains enough data then one loop cycle creates one complete |
| * data chunk with a header, body and a footer, and then flushes the |
| * chunk to the underlying stream. Otherwise, the last loop cycle |
| * creates incomplete data chunk with empty header and with no footer |
| * and stores this incomplete chunk in an internal buffer buf[] |
| */ |
| int bytesToWrite = len; |
| int inputIndex = off; /* the index of the byte[] currently being written */ |
| |
| do { |
| /* enough data to complete a chunk */ |
| if (bytesToWrite >= spaceInCurrentChunk) { |
| |
| /* header */ |
| for (int i=0; i<completeHeader.length; i++) |
| buf[i] = completeHeader[i]; |
| |
| /* data */ |
| System.arraycopy(b, inputIndex, buf, count, spaceInCurrentChunk); |
| inputIndex += spaceInCurrentChunk; |
| bytesToWrite -= spaceInCurrentChunk; |
| count += spaceInCurrentChunk; |
| |
| /* footer */ |
| buf[count++] = FOOTER[0]; |
| buf[count++] = FOOTER[1]; |
| spaceInCurrentChunk = 0; //chunk is complete |
| |
| flush(false); |
| if (checkError()){ |
| break; |
| } |
| } |
| |
| /* not enough data to build a chunk */ |
| else { |
| /* header */ |
| /* do not write header if not enough bytes to build a chunk yet */ |
| |
| /* data */ |
| System.arraycopy(b, inputIndex, buf, count, bytesToWrite); |
| count += bytesToWrite; |
| size += bytesToWrite; |
| spaceInCurrentChunk -= bytesToWrite; |
| bytesToWrite = 0; |
| |
| /* footer */ |
| /* do not write header if not enough bytes to build a chunk yet */ |
| } |
| } while (bytesToWrite > 0); |
| } |
| |
| @Override |
| public synchronized void write(int _b) { |
| byte b[] = {(byte)_b}; |
| write(b, 0, 1); |
| } |
| |
| public synchronized void reset() { |
| count = preferedHeaderSize; |
| size = 0; |
| spaceInCurrentChunk = preferredChunkDataSize; |
| } |
| |
| public int size() { |
| return size; |
| } |
| |
| @Override |
| public synchronized void close() { |
| ensureOpen(); |
| |
| /* if we have buffer a chunked send it */ |
| if (size > 0) { |
| flush(true); |
| } |
| |
| /* send a zero length chunk */ |
| flush(true); |
| |
| /* don't close the underlying stream */ |
| out = null; |
| } |
| |
| @Override |
| public synchronized void flush() { |
| ensureOpen(); |
| if (size > 0) { |
| flush(true); |
| } |
| } |
| } |