ファイルアップロードを処理するための低レベルAPIです。 * {@primary Low level API for processing file uploads.} * *
このクラスは RFC 1867 に規定されている * MIME 'multipart' フォーマットに従うデータストリームを処理するために使用されます。 * ストリーム内の(任意の)大量のデータを一定のメモリの使用量で処理することができます。 * {@primary This class can be used to process data streams conforming to MIME * 'multipart' format as defined in * RFC 1867. Arbitrarily * large amounts of data in the stream can be processed under constant * memory usage.} * *
ストリームは以下のような形式で定義されています:
* {@primary The format of the stream is defined in the following way:}
*
*
* multipart-body := preamble 1*encapsulation close-delimiter epilogue
*
*
* encapsulation := delimiter body CRLF
* delimiter := "--" boundary CRLF
* close-delimiter := "--" boudary "--"
* preamble := <ignore>
* epilogue := <ignore>
* body := header-part CRLF body-part
* header-part := 1*header CRLF
* header := header-name ":" header-value
* header-name := <printable ascii characters except ":">
* header-value := <any ascii characters except CR & LF>
* body-data := <arbitrary data>
*
body-data が他の multipart エンティティを持つことができることに注意して下さい。 * このような入れ子になったストリームの単独パスでの処理を制限つきでサポートします。 * 入れ子になったストリームは必ず親のストリームと同じ長さのバウンダリトークンを * 持っていなくてはなりません({@link #setBoundary(byte[])}を参照)。 * {@primary 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 required to have a * boundary token of the same length as the parent stream (see {@link * #setBoundary(byte[])}).} * *
以下にこのクラスに使用例を示します。
* {@primary Here is an exaple of usage of this class.}
*
*
* try {
* MultipartStream multipartStream = new MultipartStream(input,
* boundary);
* boolean nextPart = malitPartStream.skipPreamble();
* OutputStream output;
* while(nextPart) {
* header = chunks.readHeader();
* // ヘッダを処理
* // 出力ストリームを生成
* multipartStream.readBodyPart(output);
* nextPart = multipartStream.readBoundary();
* }
* } catch(MultipartStream.MalformedStreamException e) {
* // ストリームが必要とする文法に従っていない
* } catch(IOException) {
* // 読み込みまたは書き出しにてエラーが発生
* }
*
*
* {@primary try {
* MultipartStream multipartStream = new MultipartStream(input,
* boundary);
* boolean nextPart = malitPartStream.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
* }
*
* }
*
* @author Rafal Krzewski
* @author Martin Cooper
* @author Sean C. Sullivan
* @translator 日置 聡
* @editor 入江 弘憲
* @status completion
* @update 2003/04/16
*
* @version $Id: MultipartStream.java,v 1.4 2004/04/15 11:15:10 hioki Exp $
*/
public class MultipartStream
{
// ----------------------------------------------------- Manifest constants
/**
* 処理される header-part の最大の長さ(10キロバイト = 10240バイト)。
* {@primary The maximum length of header-part that will be
* processed (10 kilobytes = 10240 bytes.).}
*/
public static final int HEADER_PART_SIZE_MAX = 10240;
/**
* リクエストを処理する際に使用されるバッファのデフォルトの長さ。
* {@primary The default length of the buffer used for processing a request.}
*/
protected static final int DEFAULT_BUFSIZE = 4096;
/**
* header-part の終わりを示すバイト列(CRLFCRLF)。
* {@primary A byte sequence that marks the end of header-part
* (CRLFCRLF).}
*/
protected static final byte[] HEADER_SEPARATOR = {0x0D, 0x0A, 0x0D, 0x0A};
/**
* encapsulation の前に来る delimiter に続くバイト列(CRLF)。
* {@primary A byte sequence that that follows a delimiter that will be
* followed by an encapsulation (CRLF).}
*/
protected static final byte[] FIELD_SEPARATOR = { 0x0D, 0x0A };
/**
* ストリーム内の最後の encapsulation のdelimiter に続くバイト列(--)。
* {@primary A byte sequence that that follows a delimiter of the last
* encapsulation in the stream (--).}
*/
protected static final byte[] STREAM_TERMINATOR = { 0x2D, 0x2D };
// ----------------------------------------------------------- Data members
/**
* データの読み込み対象となる入力ストリーム。
* {@primary The input stream from which data is read.}
*/
private InputStream input;
/**
* バウンダリトークンと CRLF-- を加えた長さ。
* {@primary The length of the boundary token plus the leading CRLF--.}
*/
private int boundaryLength;
/**
* データの量(バイト単位)。
* これはデリミタを正しく検出するためにバッファ内に順番に保持されなくてはならない。
* {@primary The amount of data, in bytes, that must be kept in the buffer in order
* to detect delimiters reliably.}
*/
private int keepRegion;
/**
* ストリームを仕切るバイト列。
* {@primary The byte sequence that partitions the stream.}
*/
private byte[] boundary;
/**
* リクエストを処理する際に使用するバッファの長さ。
* {@primary The length of the buffer used for processing the request.}
*/
private int bufSize;
/**
* リクエストを処理する際に使用するバッファ。
* {@primary The buffer used for processing the request.}
*/
private byte[] buffer;
/**
* バッファ内の先頭の有効なキャラクタのインデックス。
* {@primary The index of first valid character in the buffer.}
* バッファのサイズを指定して MultipartStream を生成します。
* {@primary Constructs a MultipartStream with a custom size buffer.}
*
*
バッファはバウンダリ文字列 + "CR/LF--"の4文字 + 少なくとも1バイトのデータを
* 保持できる大きさがなくてはならないことに注意してください。
* 小さすぎるバッファサイズの設定はパフォーマンスを低下させます。
* {@primary 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 データソースを出力する InputStream 。
* {@primary The InputStream to serve as a data source.}
* @param boundary ストリームを encapsulations に分割するために使用するトークン。
* {@primary The token used for dividing the stream into
* encapsulations.}
* @param bufSize 使用するバッファのサイズ(バイト単位)。
* {@primary 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 + 4];
this.boundaryLength = boundary.length + 4;
this.keepRegion = boundary.length + 3;
this.boundary[0] = 0x0D;
this.boundary[1] = 0x0A;
this.boundary[2] = 0x2D;
this.boundary[3] = 0x2D;
System.arraycopy(boundary, 0, this.boundary, 4, boundary.length);
head = 0;
tail = 0;
}
/**
*
デフォルトのバッファサイズを使用する MultipartStream を生成します。
* {@primary Constructs a MultipartStream with a default size buffer.}
*
* @param input データソースを出力する InputStream 。
* {@primary The InputStream to serve as a data source.}
* @param boundary ストリームを encapsulations に分割するために使用するトークン。
* {@primary The token used for dividing the stream into
* encapsulations.}
*
* @exception IOException エラーが発生した場合。
* {@primary 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
/**
* 個々のパーツのヘッダを読み込む際に使用するキャラクタエンコーディングを返します。
* 設定されていないまたは null の場合にはプラットフォームのデフォルトエンコーディングを使用します。
* {@primary Retrieves the character encoding used when reading the headers of an
* individual part. When not specified, or null, the platform
* default encoding is used.}
*
* @return パーツのヘッダを読み込む際に使用するエンコーディング。
* {@primary The encoding used to read part headers.}
*/
public String getHeaderEncoding()
{
return headerEncoding;
}
/**
* 個々のパーツのヘッダを読み込む際に使用するキャラクタエンコーディングを設定します。
* 設定されていないまたは null の場合にはプラットフォームのデフォルトエンコーディングを使用します。
* {@primary 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.}
*
* @param encoding パーツのヘッダを読み込む際に使用するエンコーディング。
* {@primary The encoding used to read part headers.}
*/
public void setHeaderEncoding(String encoding)
{
headerEncoding = encoding;
}
/**
* バッファからバイトを返し、必要な分だけ補充します。
* {@primary Reads a byte from the buffer, and refills it as
* necessary.}
*
* @return 入力ストリームから読み出した次のバイト。
* {@primary The next byte from the input stream.}
*
* @exception IOException もうこれ以上データがない場合。
* {@primary 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++];
}
/**
* boundary トークンをスキップし、
* ストリーム内にさらに encapsulations があるかどうかチェックします。
* {@primary Skips a boundary token, and checks whether more
* encapsulations are contained in the stream.}
*
* @return true ストリーム内にさらに encapsulations がある場合;
* false それ以外の場合。
* {@primary true if there are more encapsulations in
* this stream; false otherwise.}
*
* @exception MalformedStreamException ストリームが不意に終了した場合、
* または文法の解釈に失敗した場合。
* {@primary if the stream ends unexpectedly 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();
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;
}
/**
*
ストリームを分割する際に使用するバウンダリトークンを変更します。 * {@primary Changes the boundary token used for partitioning the stream.} * *
このメソッドは入れ子になったストリームの単独パスでの処理を可能にします。 * {@primary This method allows single pass processing of nested multipart * streams.} * *
入れ子になったストリームのバウンダリトークンは 必ず
* 親のストリームのバウンダリトークンと同じ長さでなくてはなりません。
* {@primary The boundary token of the nested stream is required
* to be of the same length as the boundary token in parent stream.}
*
*
入れ子になったストリームのの処理の後、親のストリームのバウンダリに戻す処理は
* アプリケーションに委ねられます(手動で設定しなおす必要があります)。
* {@primary Restoring the parent stream boundary token after processing of a
* nested stream is left to the application.}
*
* @param boundary 入れ子になったストリームのパースに使用するバウンダリ。
* {@primary The boundary to be used for parsing of the nested stream.}
*
* @exception IllegalBoundaryException boundary の長さが現在使用されているものと違った場合。
* {@primary if the boundary has a different length than the one
* being currently parsed.}
*/
public void setBoundary(byte[] boundary)
throws IllegalBoundaryException
{
if (boundary.length != boundaryLength - 4)
{
throw new IllegalBoundaryException(
"The length of a boundary token can not be changed");
}
System.arraycopy(boundary, 0, this.boundary, 4, boundary.length);
}
/**
*
現在の encapsulation から
* header-part を読み込みます。
* {@primary Reads the header-part of the current
* encapsulation.}
*
*
ヘッダは末尾の CRLF マーカーを含む入力ストリームから読み出したままの状態で返されます。
* パースの処理はアプリケーションに委ねられます。
* {@primary Headers are returned verbatim to the input stream, including the
* trailing CRLF marker. Parsing is left to the
* application.}
*
*
TODO 悪意あるアクセスから保護するために、
* ヘッダサイズには上限を設けられています。
* {@primary TODO allow limiting maximum header size to
* protect against abuse.}
*
* @return 現在の encapsulation の header-part。
* {@primary The header-part of the current encapsulation.}
*
* @exception MalformedStreamException ストリームが不意に終了した場合。
* {@primary if the stream ends unexpecetedly.}
*/
public String readHeaders()
throws 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 < 4)
{
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;
}
/**
*
現在の encapsulation から
* body-data を読み込み、その内容を
* 出力ストリームに書き出します。
* {@primary Reads body-data from the current
* encapsulation and writes its contents into the
* output Stream.}
*
*
このメソッドによって(任意の)大量のデータを
* 一定のサイズのバッファを使用して処理を行うことができます
* ({@link #MultipartStream(InputStream,byte[],int) コンストラクタ} を参照)。
* {@primary Arbitrary large amounts of data can be processed by this
* method using a constant size buffer. (see {@link
* #MultipartStream(InputStream,byte[],int) constructor}).}
*
* @param output データを書き出す対象となる Stream。
* {@primary The Stream to write data into.}
*
* @return 書き出したデータの量。
* {@primary the amount of data written.}
*
* @exception MalformedStreamException ストリームが不意に終了した場合。
* {@primary if the stream ends unexpectedly.}
* @exception IOException 入出力エラーが発生した場合。
* {@primary if an i/o error occurs.}
*/
public int readBodyData(OutputStream output)
throws MalformedStreamException,
IOException
{
boolean done = false;
int pad;
int pos;
int bytesRead;
int total = 0;
while (!done)
{
// Is boundary token present somewere in the buffer?
pos = findSeparator();
if (pos != -1)
{
// Write the rest of the data before the boundary.
output.write(buffer, head, pos - head);
total += pos - head;
head = pos;
done = true;
}
else
{
// Determine how much data should be kept in the
// buffer.
if (tail - head > keepRegion)
{
pad = keepRegion;
}
else
{
pad = tail - head;
}
// Write out the data belonging to the body-data.
output.write(buffer, head, tail - head - pad);
// Move the data to the beging of the buffer.
total += tail - head - pad;
System.arraycopy(buffer, tail - pad, buffer, 0, pad);
// Refill buffer with new data.
head = 0;
bytesRead = input.read(buffer, pad, bufSize - pad);
// [pprrrrrrr]
if (bytesRead != -1)
{
tail = pad + bytesRead;
}
else
{
// The last pad amount is left in the buffer.
// Boundary can't be in there so write out the
// data you have and signal an error condition.
output.write(buffer, 0, pad);
output.flush();
total += pad;
throw new MalformedStreamException(
"Stream ended unexpectedly");
}
}
}
output.flush();
return total;
}
/**
* 現在の encapsulation から
* body-data を読み込み、これを破棄します。
* {@primary Reads body-data from the current
* encapsulation and discards it.}
*
*
このメソッドは必要のない、もしくは解釈できない encapsulations
* をスキップする際に使用してください。
* {@primary Use this method to skip encapsulations you don't need or don't
* understand.}
*
* @return 破棄したデータの量。
* {@primary The amount of data discarded.}
*
* @exception MalformedStreamException ストリームが不意に終了した場合。
* {@primary if the stream ends unexpectedly.}
* @exception IOException 入出力エラーが発生した場合。
* {@primary if an i/o error occurs.}
*/
public int discardBodyData()
throws MalformedStreamException,
IOException
{
boolean done = false;
int pad;
int pos;
int bytesRead;
int total = 0;
while (!done)
{
// Is boundary token present somewere in the buffer?
pos = findSeparator();
if (pos != -1)
{
// Write the rest of the data before the boundary.
total += pos - head;
head = pos;
done = true;
}
else
{
// Determine how much data should be kept in the
// buffer.
if (tail - head > keepRegion)
{
pad = keepRegion;
}
else
{
pad = tail - head;
}
total += tail - head - pad;
// Move the data to the beging of the buffer.
System.arraycopy(buffer, tail - pad, buffer, 0, pad);
// Refill buffer with new data.
head = 0;
bytesRead = input.read(buffer, pad, bufSize - pad);
// [pprrrrrrr]
if (bytesRead != -1)
{
tail = pad + bytesRead;
}
else
{
// The last pad amount is left in the buffer.
// Boundary can't be in there so signal an error
// condition.
total += pad;
throw new MalformedStreamException(
"Stream ended unexpectedly");
}
}
}
return total;
}
/**
* 最初の encapsulation の始まりを捜し出します。
* {@primary Finds the beginning of the first encapsulation.}
*
* @return true ストリーム内に encapsulation が見つかった場合。
* {@primary true if an encapsulation was found in
* the stream.}
*
* @exception IOException 入出力エラーが発生した場合。
* {@primary if an i/o error occurs.}
*/
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] = 0x0D;
boundary[1] = 0x0A;
}
}
/**
* 2つのバイト配列の先頭から指定されたインデックス分を比較します。
* {@primary Compares count first bytes in the arrays
* a and b.}
*
* @param a 最初の比較対象となる配列。
*{@primary The first array to compare.}
* @param b 2番目の比較対象となる配列。
* {@primary The second array to compare.}
* @param count 比較対象となる(先頭からの)バイト数。
* {@primary How many bytes should be compared.}
*
* @return true 配列 a と b の先頭から
* count 分のバイト配列が等しい場合。
* {@primary true if count first bytes in arrays
* a and b are equal.}
*/
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;
}
/**
* バッファ内の指定された位置から指定されたバイトの値を検索します。
* {@primary Searches for a byte of specified value in the buffer,
* starting at the specified position.}
*
* @param value 検索する値。
* {@primary The value to find.}
* @param pos 検索開始位置。
* {@primary The starting position for searching.}
*
* @return 見つかったバイトのバッファの先頭からの位置。
* 見つからなかった場合には -1 。
* {@primary The position of byte found, counting from beginning of the
* buffer, or -1 if not found.}
*/
protected int findByte(byte value,
int pos)
{
for (int i = pos; i < tail; i++)
{
if (buffer[i] == value)
{
return i;
}
}
return -1;
}
/**
* バッファ内の head と tail で区切られた範囲内から
* boundary を検索します。
* {@primary Searches for the boundary in the buffer
* region delimited by head and tail.}
*
* @return 見つかったバウンダリのバッファの先頭からの位置。
* 見つからなかった場合には -1 。
* {@primary The position of the boundary found, counting from the
* beginning of the buffer, or -1 if
* not found.}
*/
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;
}
/**
* このオブジェクトの文字列表現を返します。
* {@primary Returns a string representation of this object.}
*
* @return このオブジェクトの文字列表現。
* {@primary The string representation of this object.}
*/
public String toString()
{
StringBuffer sbTemp = new StringBuffer();
sbTemp.append("boundary='");
sbTemp.append(String.valueOf(boundary));
sbTemp.append("'\nbufSize=");
sbTemp.append(bufSize);
return sbTemp.toString();
}
/**
* 入力ストリームが必要な文法に従っていない場合に投げられます。
* {@primary Thrown to indicate that the input stream fails to follow the
* required syntax.}
*/
public class MalformedStreamException
extends IOException
{
/**
* 詳細メッセージなしで MalformedStreamException を生成します。
* {@primary Constructs a MalformedStreamException with no
* detail message.}
*/
public MalformedStreamException()
{
super();
}
/**
* 詳細メッセージを設定して MalformedStreamException を生成します。
* {@primary Constructs an MalformedStreamException with
* the specified detail message.}
*
* @param message 詳細メッセージ。
* {@primary The detail message.}
*/
public MalformedStreamException(String message)
{
super(message);
}
}
/**
* 不正なバウンダリトークンを設定しようとした場合に投げられます。
* {@primary Thrown upon attempt of setting an invalid boundary token.}
*/
public class IllegalBoundaryException
extends IOException
{
/**
* 詳細メッセージなしで IllegalBoundaryException を生成します。
* {@primary Constructs an IllegalBoundaryException with no
* detail message.}
*/
public IllegalBoundaryException()
{
super();
}
/**
* 詳細メッセージを設定して IllegalBoundaryException を生成します。
* {@primary Constructs an IllegalBoundaryException with
* the specified detail message.}
*
* @param message 詳細メッセージ。
* {@primary The detail message.}
*/
public IllegalBoundaryException(String message)
{
super(message);
}
}
// ------------------------------------------------------ Debugging methods
// These are the methods that were used to debug this stuff.
/*
// Dump data.
protected void dump()
{
System.out.println("01234567890");
byte[] temp = new byte[buffer.length];
for(int i=0; i