/*

public static class AutoFileItem implements FileItem {

private static FileCleaningTracker fileTracker;

static {

fileTracker = new FileCleaningTracker();

}

private ActionContext context;

// ----------------------------------------------------- Manifest constants

/**

public static final String DEFAULT_CHARSET = "ISO-8859-1";

/**

private static final int WRITE_BUFFER_SIZE = 2048;

// ----------------------------------------------------------- Data members

/**

private static int counter = 0;

/**

private String fieldName;

/**

private String contentType;

/**

private boolean isFormField;

/**

private String fileName;

/**

private int sizeThreshold;

/**

private File repository;

/**

private byte[] cachedContent;

/**

private DeferredFileOutputStream dfos;

/**

private FileItemHeaders headers;

public AutoFileItem(FileItemStream stream, ActionContext context) {

this.fieldName = stream.getFieldName();

this.contentType = stream.getContentType();

this.isFormField = stream.isFormField();

this.fileName = FilenameUtils.getName(stream.getName());

this.sizeThreshold = 10240; //TODO: make it configurable

this.repository = null;

this.context = context;

}

// ------------------------------- Methods from javax.activation.DataSource

/**

public InputStream getInputStream()

throws IOException {

if (!dfos.isInMemory()) {

return new FileInputStream(dfos.getFile());

}

if (cachedContent == null) {

cachedContent = dfos.getData();

}

return new ByteArrayInputStream(cachedContent);

}

/**

public String getContentType() {

return contentType;

}

/**

public String getCharSet() {

ParameterParser parser = new ParameterParser();

parser.setLowerCaseNames(true);

// Parameter parser can handle null input

Map params = parser.parse(getContentType(), ';');

return (String) params.get("charset");

}

/**

public String getName() {

return fileName;

}

// ------------------------------------------------------- FileItem methods

/**

public boolean isInMemory() {

return (dfos.isInMemory());

}

/**

public long getSize() {

if (cachedContent != null) {

return cachedContent.length;

} else if (dfos.isInMemory()) {

return dfos.getData().length;

} else {

return dfos.getFile().length();

}

}

/**

public byte[] get() {

if (dfos.isInMemory()) {

if (cachedContent == null) {

cachedContent = dfos.getData();

}

return cachedContent;

}

byte[] fileData = new byte[(int) getSize()];

FileInputStream fis = null;

try {

fis = new FileInputStream(dfos.getFile());

fis.read(fileData);

} catch (IOException e) {

fileData = null;

} finally {

if (fis != null) {

try {

fis.close();

} catch (IOException e) {

// ignore

}

}

}

return fileData;

}

/**

public String getString(final String charset)

throws UnsupportedEncodingException {

return new String(get(), charset);

}

/**

public String getString() {

byte[] rawdata = get();

String charset = getCharSet();

if (charset == null) {

charset = DEFAULT_CHARSET;

}

try {

return new String(rawdata, charset);

} catch (UnsupportedEncodingException e) {

return new String(rawdata);

}

}

/**

public void write(File file) throws Exception {

if (isInMemory()) {

FileOutputStream fout = null;

try {

fout = new FileOutputStream(file);

fout.write(get());

} finally {

if (fout != null) {

fout.close();

}

}

} else {

File outputFile = getStoreLocation();

if (outputFile != null) {

/*

if (!outputFile.renameTo(file)) {

BufferedInputStream in = null;

BufferedOutputStream out = null;

try {

in = new BufferedInputStream(

new FileInputStream(outputFile));

out = new BufferedOutputStream(

new FileOutputStream(file));

byte[] bytes = new byte[WRITE_BUFFER_SIZE];

int s = 0;

while ((s = in.read(bytes)) != -1) {

out.write(bytes, 0, s);

}

} finally {

if (in != null) {

try {

in.close();

} catch (IOException e) {

// ignore

}

}

if (out != null) {

try {

out.close();

} catch (IOException e) {

// ignore

}

}

}

}

} else {

/*

throw new FileUploadException(

"Cannot write uploaded file to disk!");

}

}

}

/**

public void delete() {

cachedContent = null;

File outputFile = getStoreLocation();

if (outputFile != null && outputFile.exists()) {

outputFile.delete();

}

}

/**

public String getFieldName() {

return fieldName;

}

/**

public void setFieldName(String fieldName) {

this.fieldName = fieldName;

}

/**

public boolean isFormField() {

return isFormField;

}

/**

public void setFormField(boolean state) {

isFormField = state;

}

/**

public OutputStream getOutputStream() throws IOException {

if (dfos == null) {

File outputFile = null;

if (sizeThreshold != Integer.MAX_VALUE) {

outputFile = getTempFile(context);

}

dfos = new DeferredFileOutputStream(sizeThreshold, outputFile);

}

return dfos;

}

// --------------------------------------------------------- Public methods

/**

public File getStoreLocation() {

return dfos.getFile();

}

// ------------------------------------------------------ Protected methods

/**

protected void finalize() {

File outputFile = dfos.getFile();

if (outputFile != null && outputFile.exists()) {

outputFile.delete();

}

}

/**

protected File getTempFile(ActionContext context) {

File tempDir = repository;

if (tempDir == null) {

tempDir = context.app().tmpDir();

}

String fileName = "upload_" + getUniqueId() + ".tmp";

File f = new File(tempDir, fileName);

fileTracker.track(f, this);

return f;

}

// -------------------------------------------------------- Private methods

/**

private static String getUniqueId() {

int current;

synchronized (DiskFileItem.class) {

current = counter++;

}

String id = Integer.toString(current);

// If you manage to get more than 100 million of ids, you'll

// start getting ids longer than 8 characters.

if (current < 100000000) {

id = ("00000000" + id).substring(id.length());

}

return id;

}

public String toString() {

return "name=" + this.getName() + ", StoreLocation=" + String.valueOf(this.getStoreLocation()) + ", size=" + this.getSize() + "bytes, " + "isFormField=" + isFormField() + ", FieldName=" + this.getFieldName();

}

/**

@Override

public FileItemHeaders getHeaders() {

return headers;

}

/**

@Override

public void setHeaders(FileItemHeaders pHeaders) {

headers = pHeaders;

}

}

@Override

public Map<String, String[]> parse(ActionContext context) {

H.Request request = context.req();

InputStream body = request.inputStream();

Map<String, String[]> result = new HashMap<String, String[]>();

try {

FileItemIteratorImpl iter = new FileItemIteratorImpl(body, request.header("content-type"), request.characterEncoding());

while (iter.hasNext()) {

FileItemStream item = iter.next();

FileItem fileItem = new AutoFileItem(item, context);

try {

IO.copy(item.openStream(), fileItem.getOutputStream(), true);

} catch (FileUploadIOException e) {

throw (FileUploadException) e.getCause();

} catch (IOException e) {

throw new IOFileUploadException("Processing of " + MULTIPART_FORM_DATA + " request failed. " + e.getMessage(), e);

}

if (fileItem.isFormField()) {

// must resolve encoding

String _encoding = request.characterEncoding(); // this is our default

String _contentType = fileItem.getContentType();

if( _contentType != null ) {

ContentTypeWithEncoding contentTypeEncoding = ContentTypeWithEncoding.parse(_contentType);

if( contentTypeEncoding.encoding != null ) {

_encoding = contentTypeEncoding.encoding;

}

}

MapUtil.mergeValueInMap(result, fileItem.getFieldName(), fileItem.getString(_encoding));

} else {

context.addUpload(fileItem.getFieldName(), UploadFileStorageService.store(fileItem, context.app()));

MapUtil.mergeValueInMap(result, fileItem.getFieldName(), fileItem.getFieldName());

}

}

} catch (FileUploadIOException e) {

logger.debug(e, "error");

throw new IllegalStateException("Error when handling upload", e);

} catch (IOException e) {

logger.debug(e, "error");

throw new IllegalStateException("Error when handling upload", e);

} catch (FileUploadException e) {

logger.debug(e, "error");

throw new IllegalStateException("Error when handling upload", e);

} catch (Exception e) {

logger.debug(e, "error");

throw new UnexpectedException(e);

}

return result;

} // ---------------------------------------------------------- Class methods

// ----------------------------------------------------- Manifest constants

/**

private static final String CONTENT_TYPE = "Content-type";

/**

private static final String CONTENT_DISPOSITION = "Content-disposition";

/**

private static final String FORM_DATA = "form-data";

/**

private static final String ATTACHMENT = "attachment";

/**

private static final String MULTIPART = "multipart/";

/**

private static final String MULTIPART_FORM_DATA = "multipart/form-data";

/**

private static final String MULTIPART_MIXED = "multipart/mixed";

// ----------------------------------------------------------- Data members

/**

private long sizeMax = -1;

/**

private long fileSizeMax = -1;

// ------------------------------------------------------ Protected methods

/**

private byte[] getBoundary(String contentType) {

ParameterParser parser = new ParameterParser();

parser.setLowerCaseNames(true);

// Parameter parser can handle null input

Map params = parser.parse(contentType, ';');

String boundaryStr = (String) params.get("boundary");

if (boundaryStr == null) {

return null;

}

byte[] boundary;

try {

boundary = boundaryStr.getBytes("ISO-8859-1");

} catch (UnsupportedEncodingException e) {

boundary = boundaryStr.getBytes();

}

return boundary;

}

/**

private String getFileName(Map /* String, String */ headers) {

String fileName = null;

String cd = getHeader(headers, CONTENT_DISPOSITION);

if (cd != null) {

String cdl = cd.toLowerCase();

if (cdl.startsWith(FORM_DATA) || cdl.startsWith(ATTACHMENT)) {

ParameterParser parser = new ParameterParser();

parser.setLowerCaseNames(true);

// Parameter parser can handle null input

Map params = parser.parse(cd, ';');

if (params.containsKey("filename")) {

fileName = (String) params.get("filename");

if (fileName != null) {

fileName = fileName.trim();

// IE7 returning fullpath name (#300920)

if (fileName.indexOf('\\') != -1) {

fileName = fileName.substring(fileName.lastIndexOf('\\') + 1);

}

} else {

// Even if there is no value, the parameter is present,

// so we return an empty file name rather than no file

// name.

fileName = "";

}

}

}

}

return fileName;

}

/**

private String getFieldName(Map /* String, String */ headers) {

String fieldName = null;

String cd = getHeader(headers, CONTENT_DISPOSITION);

if (cd != null && cd.toLowerCase().startsWith(FORM_DATA)) {

ParameterParser parser = new ParameterParser();

parser.setLowerCaseNames(true);

// Parameter parser can handle null input

Map params = parser.parse(cd, ';');

fieldName = (String) params.get("name");

if (fieldName != null) {

fieldName = fieldName.trim();

}

}

return fieldName;

}

/**

private Map /* String, String */ parseHeaders(String headerPart) {

final int len = headerPart.length();

Map<String, String> headers = new HashMap<String, String>();

int start = 0;

for (; ;) {

int end = parseEndOfLine(headerPart, start);

if (start == end) {

break;

}

String header = headerPart.substring(start, end);

start = end + 2;

while (start < len) {

int nonWs = start;

while (nonWs < len) {

char c = headerPart.charAt(nonWs);

if (c != ' ' && c != '\t') {

break;

}

++nonWs;

}

if (nonWs == start) {

break;

}

// Continuation line found

end = parseEndOfLine(headerPart, nonWs);

header += " " + headerPart.substring(nonWs, end);

start = end + 2;

}

parseHeaderLine(headers, header);

}

return headers;

}

/**

private int parseEndOfLine(String headerPart, int end) {

int index = end;

for (; ;) {

int offset = headerPart.indexOf('\r', index);

if (offset == -1 || offset + 1 >= headerPart.length()) {

throw new IllegalStateException("Expected headers to be terminated by an empty line.");

}

if (headerPart.charAt(offset + 1) == '\n') {

return offset;

}

index = offset + 1;

}

}

/**

private void parseHeaderLine(Map<String, String> headers, String header) {

final int colonOffset = header.indexOf(':');

if (colonOffset == -1) {

// This header line is malformed, skip it.

return;

}

String headerName = header.substring(0, colonOffset).trim().toLowerCase();

String headerValue = header.substring(header.indexOf(':') + 1).trim();

if (getHeader(headers, headerName) != null) {

// More that one heder of that name exists,

// append to the list.

headers.put(headerName, getHeader(headers, headerName) + ',' + headerValue);

} else {

headers.put(headerName, headerValue);

}

}

/**

private final String getHeader(Map /* String, String */ headers, String name) {

return (String) headers.get(name.toLowerCase());

}

/**

private class FileItemIteratorImpl implements FileItemIterator {

/**

private class FileItemStreamImpl implements FileItemStream {

/**

private final String contentType;

/**

private final String fieldName;

/**

private final String name;

/**

private final boolean formField;

/**

private final InputStream stream;

/**

private boolean opened;

private FileItemHeaders fileItemHeaders;

/**

FileItemStreamImpl(String pName, String pFieldName, String pContentType, boolean pFormField) {

name = pName;

fieldName = pFieldName;

contentType = pContentType;

formField = pFormField;

InputStream istream = multi.newInputStream();

if (fileSizeMax != -1) {

istream = new LimitedInputStream(istream, fileSizeMax) {

protected void raiseError(long pSizeMax, long pCount) throws IOException {

FileUploadException e = new FileSizeLimitExceededException("The field " + fieldName + " exceeds its maximum permitted " + " size of " + pSizeMax + " characters.", pCount, pSizeMax);

throw new FileUploadIOException(e);

}

};

}

stream = istream;

}

public FileItemHeaders getHeaders() {

return fileItemHeaders;

}

public void setHeaders(FileItemHeaders fileItemHeaders) {

this.fileItemHeaders = fileItemHeaders;

}

/**

public String getContentType() {

return contentType;

}

/**

public String getFieldName() {

return fieldName;

}

/**

public String getName() {

return name;

}

/**

public boolean isFormField() {

return formField;

}

/**

public InputStream openStream() throws IOException {

if (opened) {

throw new IllegalStateException("The stream was already opened.");

}

if (((Closeable) stream).isClosed()) {

throw new FileItemStream.ItemSkippedException();

}

return stream;

}

/**

void close() throws IOException {

stream.close();

}

}

/**

private final MultipartStream multi;

/**

private final byte[] boundary;

/**

private FileItemStreamImpl currentItem;

/**

private String currentFieldName;

/**

private boolean skipPreamble;

/**

private boolean itemValid;

/**

private boolean eof;

/**