public MultipartStream() 
{
    // ----------------------------------------------------------- Constructors
        this(null, null, null);
}

Creates a new instance.

 public MultipartStream(InputStream input,
    byte[] boundary) 
{
        this(input, boundary, DEFAULT_BUFSIZE, null);
}

Constructs a MultipartStream with a default size buffer.

Parameters:

input - The InputStream to serve as a data source.

boundary - The token used for dividing the stream into encapsulations.

Also see:

MultipartStream(InputStream, byte[], int, ProgressNotifier)

 public MultipartStream(InputStream input,
    byte[] boundary,
    int bufSize) 
{
        this(input, boundary, bufSize, null);
}

Constructs a MultipartStream with a custom size buffer and no progress notifier.

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.

Parameters:

input - The InputStream to serve as a data source.

boundary - The token used for dividing the stream into encapsulations.

bufSize - The size of the buffer to be used, in bytes.

Also see:

MultipartStream(InputStream, byte[], ProgressNotifier)

 MultipartStream(InputStream input,
    byte[] boundary,
    MultipartStream.ProgressNotifier pNotifier) 
{
        this(input, boundary, DEFAULT_BUFSIZE, pNotifier);
}

Constructs a MultipartStream with a default size buffer.

Parameters:

input - The InputStream to serve as a data source.

boundary - The token used for dividing the stream into encapsulations.

pNotifier - An object for calling the progress listener, if any.

Also see:

MultipartStream(InputStream, byte[], int, ProgressNotifier)

 MultipartStream(InputStream input,
    byte[] boundary,
    int bufSize,
    MultipartStream.ProgressNotifier pNotifier) 
{
        this.input = input;
        this.bufSize = bufSize;
        this.buffer = new byte[bufSize];
        this.notifier = pNotifier;
        // 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;
}

Constructs a MultipartStream with a custom size buffer.

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.

Parameters:

input - The InputStream to serve as a data source.

boundary - The token used for dividing the stream into encapsulations.

bufSize - The size of the buffer to be used, in bytes.

pNotifier - The notifier, which is used for calling the progress listener, if any.

Also see:

MultipartStream(InputStream, byte[], ProgressNotifier)

 public static boolean arrayequals(byte[] a,
    byte[] b,
    int count) 
{
        for (int i = 0; i <  count; i++) {
            if (a[i] != b[i]) {
                return false;
            }
        }
        return true;
}

Compares count first bytes in the arrays a and b.

 public int discardBodyData() throws IOException, MultipartStream.MalformedStreamException 
{
        return readBodyData(null);
}

Reads body-data from the current encapsulation and discards it.

Use this method to skip encapsulations you don't need or don't understand.

 protected int findByte(byte value,
    int pos) 
{
        for (int i = pos; i <  tail; i++) {
            if (buffer[i] == value) {
                return i;
            }
        }
        return -1;
}

Searches for a byte of specified value in the buffer, starting at the specified position.

 protected int findSeparator() 
{
        int first;
        int match = 0;
        int maxpos = tail - boundaryLength;
        for (first = head;
        (first < = maxpos) && (match != boundaryLength);
        first++) {
            first = findByte(boundary[0], first);
            if (first == -1 || (first  > maxpos)) {
                return -1;
            }
            for (match = 1; match <  boundaryLength; match++) {
                if (buffer[first + match] != boundary[match]) {
                    break;
                }
            }
        }
        if (match == boundaryLength) {
            return first - 1;
        }
        return -1;
}

Searches for the boundary in the buffer region delimited by head and tail.

 public String getHeaderEncoding() 
{
        return headerEncoding;
}

Retrieves the character encoding used when reading the headers of an individual part. When not specified, or null, the platform default encoding is used.

 MultipartStream.ItemInputStream newInputStream() 
{
        return new ItemInputStream();
}

Creates a new ItemInputStream .

 public int readBodyData(OutputStream output) throws IOException, MultipartStream.MalformedStreamException 
{
        final InputStream istream = newInputStream();
        return (int) Streams.copy(istream, output, false);
}

Reads body-data from the current encapsulation and writes its contents into the output Stream.

Arbitrary large amounts of data can be processed by this method using a constant size buffer. (see constructor ).

 public boolean readBoundary() throws MultipartStream.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;
}

Skips a boundary token, and checks whether more encapsulations are contained in the stream.

 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");
            }
            notifier.noteBytesRead(tail);
        }
        return buffer[head++];
}

Reads a byte from the buffer, and refills it as necessary.

 public String readHeaders() throws MultipartStream.MalformedStreamException 
{
        int i = 0;
        byte[] b = new byte[1];
        // to support multi-byte characters
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        int sizeMax = HEADER_PART_SIZE_MAX;
        int size = 0;
        while (i <  HEADER_SEPARATOR.length) {
            try {
                b[0] = readByte();
            } catch (IOException e) {
                throw new MalformedStreamException("Stream ended unexpectedly");
            }
            size++;
            if (b[0] == HEADER_SEPARATOR[i]) {
                i++;
            } else {
                i = 0;
            }
            if (size < = sizeMax) {
                baos.write(b[0]);
            }
        }
        String headers = null;
        if (headerEncoding != null) {
            try {
                headers = baos.toString(headerEncoding);
            } catch (UnsupportedEncodingException e) {
                // Fall back to platform default if specified encoding is not
                // supported.
                headers = baos.toString();
            }
        } else {
            headers = baos.toString();
        }
        return headers;
}

Reads the header-part of the current encapsulation.

Headers are returned verbatim to the input stream, including the trailing CRLF marker. Parsing is left to the application.

TODO allow limiting maximum header size to protect against abuse.

 public  void setBoundary(byte[] boundary) throws MultipartStream.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);
}

Changes the boundary token used for partitioning the stream.

This method allows single pass processing of nested multipart streams.

The boundary token of the nested stream is required to be of the same length as the boundary token in parent stream.

Restoring the parent stream boundary token after processing of a nested stream is left to the application.

 public  void setHeaderEncoding(String encoding) 
{
        headerEncoding = encoding;
}

Specifies the character encoding to be used when reading the headers of individual parts. When not specified, or null, the platform default encoding is used.

 public boolean skipPreamble() throws IOException 
{
        // First delimiter may be not preceeded with a CRLF.
        System.arraycopy(boundary, 2, boundary, 0, boundary.length - 2);
        boundaryLength = boundary.length - 2;
        try {
            // Discard all data up to the delimiter.
            discardBodyData();
            // Read boundary - if succeded, the stream contains an
            // encapsulation.
            return readBoundary();
        } catch (MalformedStreamException e) {
            return false;
        } finally {
            // Restore delimiter.
            System.arraycopy(boundary, 0, boundary, 2, boundary.length - 2);
            boundaryLength = boundary.length;
            boundary[0] = CR;
            boundary[1] = LF;
        }
}

Finds the beginning of the first encapsulation.