/* * Copyright 2001-2005 The Apache Software Foundation * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *     http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package org.apache.commons.fileupload;import java.io.ByteArrayOutputStream;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.io.UnsupportedEncodingException;/** * <p> Low level API for processing file uploads. * * <p> This class can be used to process data streams conforming to MIME * 'multipart' format as defined in * <a href="http://www.ietf.org/rfc/rfc1867.txt">RFC 1867</a>. Arbitrarily * large amounts of data in the stream can be processed under constant * memory usage. * * <p> The format of the stream is defined in the following way:<br> * * <code> *   multipart-body := preamble 1*encapsulation close-delimiter epilogue<br> *   encapsulation := delimiter body CRLF<br> *   delimiter := "--" boundary CRLF<br> *   close-delimiter := "--" boudary "--"<br> *   preamble := &lt;ignore&gt;<br> *   epilogue := &lt;ignore&gt;<br> *   body := header-part CRLF body-part<br> *   header-part := 1*header CRLF<br> *   header := header-name ":" header-value<br> *   header-name := &lt;printable ascii characters except ":"&gt;<br> *   header-value := &lt;any ascii characters except CR & LF&gt;<br> *   body-data := &lt;arbitrary data&gt;<br> * </code> * * <p>Note that body-data can contain another mulipart entity.  There * is limited support for single pass processing of such nested * streams.  The nested stream is <strong>required</strong> to have a * boundary token of the same length as the parent stream (see {@link * #setBoundary(byte[])}). * * <p>Here is an example of usage of this class.<br> * * <pre> *    try { *        MultipartStream multipartStream = new MultipartStream(input, *                                                              boundary); *        boolean nextPart = multipartStream.skipPreamble(); *        OutputStream output; *        while(nextPart) { *            header = chunks.readHeader(); *            // process headers *            // create some output stream *            multipartStream.readBodyPart(output); *            nextPart = multipartStream.readBoundary(); *        } *    } catch(MultipartStream.MalformedStreamException e) { *          // the stream failed to follow required syntax *    } catch(IOException) { *          // a read or write error occurred *    } * * </pre> * * @author <a href="mailto:Rafal.Krzewski@e-point.pl">Rafal Krzewski</a> * @author <a href="mailto:martinc@apache.org">Martin Cooper</a> * @author Sean C. Sullivan * * @version $Id: MultipartStream.java 353822 2005-12-04 06:33:55Z martinc $ */public class MultipartStream {    // ----------------------------------------------------- Manifest constants    /**     * The Carriage Return ASCII character value.     */    public static final byte CR = 0x0D;    /**     * The Line Feed ASCII character value.     */    public static final byte LF = 0x0A;    /**     * The dash (-) ASCII character value.     */    public static final byte DASH = 0x2D;    /**     * The maximum length of <code>header-part</code> that will be     * processed (10 kilobytes = 10240 bytes.).     */    public static final int HEADER_PART_SIZE_MAX = 10240;    /**     * The default length of the buffer used for processing a request.     */    protected static final int DEFAULT_BUFSIZE = 4096;    /**     * A byte sequence that marks the end of <code>header-part</code>     * (<code>CRLFCRLF</code>).     */    protected static final byte[] HEADER_SEPARATOR = {            CR, LF, CR, LF };    /**     * A byte sequence that that follows a delimiter that will be     * followed by an encapsulation (<code>CRLF</code>).     */    protected static final byte[] FIELD_SEPARATOR = {            CR, LF};    /**     * A byte sequence that that follows a delimiter of the last     * encapsulation in the stream (<code>--</code>).     */    protected static final byte[] STREAM_TERMINATOR = {            DASH, DASH};    /**     * A byte sequence that precedes a boundary (<code>CRLF--</code>).     */    protected static final byte[] BOUNDARY_PREFIX = {            CR, LF, DASH, DASH};    /**     * The number of bytes, over and above the boundary size, to use for the     * keep region.     */    private static final int KEEP_REGION_PAD = 3;    // ----------------------------------------------------------- Data members    /**     * The input stream from which data is read.     */    private InputStream input;    /**     * The length of the boundary token plus the leading <code>CRLF--</code>.     */    private int boundaryLength;    /**     * The amount of data, in bytes, that must be kept in the buffer in order     * to detect delimiters reliably.     */    private int keepRegion;    /**     * The byte sequence that partitions the stream.     */    private byte[] boundary;    /**     * The length of the buffer used for processing the request.     */    private int bufSize;    /**     * The buffer used for processing the request.     */    private byte[] buffer;    /**     * The index of first valid character in the buffer.     * <br>     * 0 <= head < bufSize     */    private int head;    /**     * The index of last valid characer in the buffer + 1.     * <br>     * 0 <= tail <= bufSize     */    private int tail;    /**     * The content encoding to use when reading headers.     */    private String headerEncoding;    // ----------------------------------------------------------- Constructors    /**     * Default constructor.     *     * @see #MultipartStream(InputStream, byte[], int)     * @see #MultipartStream(InputStream, byte[])     *     */    public MultipartStream() {    }    /**     * <p> Constructs a <code>MultipartStream</code> with a custom size buffer.     *     * <p> Note that the buffer must be at least big enough to contain the     * boundary string, plus 4 characters for CR/LF and double dash, plus at     * least one byte of data.  Too small a buffer size setting will degrade     * performance.     *     * @param input    The <code>InputStream</code> to serve as a data source.     * @param boundary The token used for dividing the stream into     *                 <code>encapsulations</code>.     * @param bufSize  The size of the buffer to be used, in bytes.     *     *     * @see #MultipartStream()     * @see #MultipartStream(InputStream, byte[])     *     */    public MultipartStream(InputStream input,                           byte[] boundary,                           int bufSize) {        this.input = input;        this.bufSize = bufSize;        this.buffer = new byte[bufSize];        // We prepend CR/LF to the boundary to chop trailng CR/LF from        // body-data tokens.        this.boundary = new byte[boundary.length + BOUNDARY_PREFIX.length];        this.boundaryLength = boundary.length + BOUNDARY_PREFIX.length;        this.keepRegion = boundary.length + KEEP_REGION_PAD;        System.arraycopy(BOUNDARY_PREFIX, 0, this.boundary, 0,                BOUNDARY_PREFIX.length);        System.arraycopy(boundary, 0, this.boundary, BOUNDARY_PREFIX.length,                boundary.length);        head = 0;        tail = 0;    }    /**     * <p> Constructs a <code>MultipartStream</code> with a default size buffer.     *     * @param input    The <code>InputStream</code> to serve as a data source.     * @param boundary The token used for dividing the stream into     *                 <code>encapsulations</code>.     *     * @throws IOException when an error occurs.     *     * @see #MultipartStream()     * @see #MultipartStream(InputStream, byte[], int)     *     */    public MultipartStream(InputStream input,                           byte[] boundary)        throws IOException {        this(input, boundary, DEFAULT_BUFSIZE);    }    // --------------------------------------------------------- Public methods    /**     * Retrieves the character encoding used when reading the headers of an     * individual part. When not specified, or <code>null</code>, the platform     * default encoding is used.     *     * @return The encoding used to read part headers.     */    public String getHeaderEncoding() {        return headerEncoding;    }    /**     * Specifies the character encoding to be used when reading the headers of     * individual parts. When not specified, or <code>null</code>, the platform     * default encoding is used.     *     * @param encoding The encoding used to read part headers.     */    public void setHeaderEncoding(String encoding) {        headerEncoding = encoding;    }    /**     * Reads a byte from the <code>buffer</code>, and refills it as     * necessary.     *     * @return The next byte from the input stream.     *     * @throws IOException if there is no more data available.     */    public byte readByte()        throws IOException {        // Buffer depleted ?        if (head == tail) {            head = 0;            // Refill.            tail = input.read(buffer, head, bufSize);            if (tail == -1) {                // No more data available.                throw new IOException("No more data is available");            }        }        return buffer[head++];    }    /**     * Skips a <code>boundary</code> token, and checks whether more     * <code>encapsulations</code> are contained in the stream.     *     * @return <code>true</code> if there are more encapsulations in     *         this stream; <code>false</code> otherwise.     *     * @throws MalformedStreamException if the stream ends unexpecetedly or     *                                  fails to follow required syntax.     */    public boolean readBoundary()        throws MalformedStreamException {        byte[] marker = new byte[2];        boolean nextChunk = false;        head += boundaryLength;        try {            marker[0] = readByte();            if (marker[0] == LF) {                // Work around IE5 Mac bug with input type=image.                // Because the boundary delimiter, not including the trailing                // CRLF, must not appear within any file (RFC 2046, section                // 5.1.1), we know the missing CR is due to a buggy browser                // rather than a file containing something similar to a                // boundary.                return true;            }            marker[1] = readByte();            if (arrayequals(marker, STREAM_TERMINATOR, 2)) {                nextChunk = false;            } else if (arrayequals(marker, FIELD_SEPARATOR, 2)) {                nextChunk = true;            } else {                throw new MalformedStreamException(                        "Unexpected characters follow a boundary");            }        } catch (IOException e) {            throw new MalformedStreamException("Stream ended unexpectedly");        }        return nextChunk;    }    /**     * <p>Changes the boundary token used for partitioning the stream.     *     * <p>This method allows single pass processing of nested multipart     * streams.     *     * <p>The boundary token of the nested stream is <code>required</code>     * to be of the same length as the boundary token in parent stream.     *     * <p>Restoring the parent stream boundary token after processing of a     * nested stream is left to the application.     *     * @param boundary The boundary to be used for parsing of the nested     *                 stream.     *     * @throws IllegalBoundaryException if the <code>boundary</code>     *                                  has a different length than the one     *                                  being currently parsed.     */    public void setBoundary(byte[] boundary)        throws IllegalBoundaryException {        if (boundary.length != boundaryLength - BOUNDARY_PREFIX.length) {            throw new IllegalBoundaryException(                    "The length of a boundary token can not be changed");        }        System.arraycopy(boundary, 0, this.boundary, BOUNDARY_PREFIX.length,                boundary.length);    }    /**     * <p>Reads the <code>header-part</code> of the current     * <code>encapsulation</code>.     *     * <p>Headers are returned verbatim to the input stream, including the     * trailing <code>CRLF</code> marker. Parsing is left to the