true if the file contents will be read
* from memory; false otherwise.
*/
public boolean isInMemory() {
if (cachedContent != null) {
return true;
}
return dfos.isInMemory();
}
/**
* Returns the size of the file.
*
* @return The size of the file, in bytes.
*/
public long getSize() {
if (size >= 0) {
return size;
} else if (cachedContent != null) {
return cachedContent.length;
} else if (dfos.isInMemory()) {
return dfos.getData().length;
} else {
return dfos.getFile().length();
}
}
/**
* Returns the contents of the file as an array of bytes. If the
* contents of the file were not yet cached in memory, they will be
* loaded from the disk storage and cached.
*
* @return The contents of the file as an array of bytes.
*/
public byte[] get() {
if (isInMemory()) {
if (cachedContent == null) {
cachedContent = dfos.getData();
}
return cachedContent;
}
byte[] fileData = new byte[(int) getSize()];
InputStream fis = null;
try {
fis = new BufferedInputStream(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;
}
/**
* Returns the contents of the file as a String, using the specified
* encoding. This method uses {@link #get()} to retrieve the
* contents of the file.
*
* @param charset The charset to use.
*
* @return The contents of the file, as a string.
*
* @throws UnsupportedEncodingException if the requested character
* encoding is not available.
*/
public String getString(final String charset)
throws UnsupportedEncodingException {
return new String(get(), charset);
}
/**
* Returns the contents of the file as a String, using the default
* character encoding. This method uses {@link #get()} to retrieve the
* contents of the file.
*
* TODO Consider making this method throw UnsupportedEncodingException.
*
* @return The contents of the file, as a string.
*/
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);
}
}
/**
* A convenience method to write an uploaded item to disk. The client code
* is not concerned with whether or not the item is stored in memory, or on
* disk in a temporary location. They just want to write the uploaded item
* to a file.
* * This implementation first attempts to rename the uploaded item to the * specified destination file, if the item was originally written to disk. * Otherwise, the data will be copied to the specified file. *
* This method is only guaranteed to work once, the first time it
* is invoked for a particular item. This is because, in the event that the
* method renames a temporary file, that file will no longer be available
* to copy or rename again at a later time.
*
* @param file The File into which the uploaded item should
* be stored.
*
* @throws Exception if an error occurs.
*/
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) {
// Save the length of the file
size = outputFile.length();
/*
* The uploaded file is being stored on disk
* in a temporary location so move it to the
* desired file.
*/
if (!outputFile.renameTo(file)) {
BufferedInputStream in = null;
BufferedOutputStream out = null;
try {
in = new BufferedInputStream(
new FileInputStream(outputFile));
out = new BufferedOutputStream(
new FileOutputStream(file));
IOUtils.copy(in, out);
} finally {
if (in != null) {
try {
in.close();
} catch (IOException e) {
// ignore
}
}
if (out != null) {
try {
out.close();
} catch (IOException e) {
// ignore
}
}
}
}
} else {
/*
* For whatever reason we cannot write the
* file to disk.
*/
throw new FileUploadException(
"Cannot write uploaded file to disk!");
}
}
}
/**
* Deletes the underlying storage for a file item, including deleting any
* associated temporary disk file. Although this storage will be deleted
* automatically when the FileItem instance is garbage
* collected, this method can be used to ensure that this is done at an
* earlier time, thus preserving system resources.
*/
public void delete() {
cachedContent = null;
File outputFile = getStoreLocation();
if (outputFile != null && outputFile.exists()) {
outputFile.delete();
}
}
/**
* Returns the name of the field in the multipart form corresponding to
* this file item.
*
* @return The name of the form field.
*
* @see #setFieldName(java.lang.String)
*
*/
public String getFieldName() {
return fieldName;
}
/**
* Sets the field name used to reference this file item.
*
* @param fieldName The name of the form field.
*
* @see #getFieldName()
*
*/
public void setFieldName(String fieldName) {
this.fieldName = fieldName;
}
/**
* Determines whether or not a FileItem instance represents
* a simple form field.
*
* @return true if the instance represents a simple form
* field; false if it represents an uploaded file.
*
* @see #setFormField(boolean)
*
*/
public boolean isFormField() {
return isFormField;
}
/**
* Specifies whether or not a FileItem instance represents
* a simple form field.
*
* @param state true if the instance represents a simple form
* field; false if it represents an uploaded file.
*
* @see #isFormField()
*
*/
public void setFormField(boolean state) {
isFormField = state;
}
/**
* Returns an {@link java.io.OutputStream OutputStream} that can
* be used for storing the contents of the file.
*
* @return An {@link java.io.OutputStream OutputStream} that can be used
* for storing the contensts of the file.
*
* @throws IOException if an error occurs.
*/
public OutputStream getOutputStream()
throws IOException {
if (dfos == null) {
File outputFile = getTempFile();
dfos = new DeferredFileOutputStream(sizeThreshold, outputFile);
}
return dfos;
}
// --------------------------------------------------------- Public methods
/**
* Returns the {@link java.io.File} object for the FileItem's
* data's temporary location on the disk. Note that for
* FileItems that have their data stored in memory,
* this method will return null. When handling large
* files, you can use {@link java.io.File#renameTo(java.io.File)} to
* move the file to new location without copying the data, if the
* source and destination locations reside within the same logical
* volume.
*
* @return The data file, or null if the data is stored in
* memory.
*/
public File getStoreLocation() {
if (dfos == null) {
return null;
}
return dfos.getFile();
}
// ------------------------------------------------------ Protected methods
/**
* Removes the file contents from the temporary storage.
*/
@Override
protected void finalize() {
File outputFile = dfos.getFile();
if (outputFile != null && outputFile.exists()) {
outputFile.delete();
}
}
/**
* Creates and returns a {@link java.io.File File} representing a uniquely
* named temporary file in the configured repository path. The lifetime of
* the file is tied to the lifetime of the FileItem instance;
* the file will be deleted when the instance is garbage collected.
*
* @return The {@link java.io.File File} to be used for temporary storage.
*/
protected File getTempFile() {
if (tempFile == null) {
File tempDir = repository;
if (tempDir == null) {
tempDir = new File(System.getProperty("java.io.tmpdir"));
}
String tempFileName = format("upload_%s_%s.tmp", UID, getUniqueId());
tempFile = new File(tempDir, tempFileName);
}
return tempFile;
}
// -------------------------------------------------------- Private methods
/**
* Returns an identifier that is unique within the class loader used to
* load this class, but does not have random-like apearance.
*
* @return A String with the non-random looking instance identifier.
*/
private static String getUniqueId() {
final int limit = 100000000;
int current = COUNTER.getAndIncrement();
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 < limit) {
id = ("00000000" + id).substring(id.length());
}
return id;
}
/**
* Returns a string representation of this object.
*
* @return a string representation of this object.
*/
@Override
public String toString() {
return format("name=%s, StoreLocation=%s, size=%s bytes, isFormField=%s, FieldName=%s",
getName(), getStoreLocation(), Long.valueOf(getSize()),
Boolean.valueOf(isFormField()), getFieldName());
}
// -------------------------------------------------- Serialization methods
/**
* Writes the state of this object during serialization.
*
* @param out The stream to which the state should be written.
*
* @throws IOException if an error occurs.
*/
private void writeObject(ObjectOutputStream out) throws IOException {
// Read the data
if (dfos.isInMemory()) {
cachedContent = get();
} else {
cachedContent = null;
dfosFile = dfos.getFile();
}
// write out values
out.defaultWriteObject();
}
/**
* Reads the state of this object during deserialization.
*
* @param in The stream from which the state should be read.
*
* @throws IOException if an error occurs.
* @throws ClassNotFoundException if class cannot be found.
*/
private void readObject(ObjectInputStream in)
throws IOException, ClassNotFoundException {
// read values
in.defaultReadObject();
/* One expected use of serialization is to migrate HTTP sessions
* containing a DiskFileItem between JVMs. Particularly if the JVMs are
* on different machines It is possible that the repository location is
* not valid so validate it.
*/
if (repository != null) {
if (repository.isDirectory()) {
// Check path for nulls
if (repository.getPath().contains("\0")) {
throw new IOException(format(
"The repository [%s] contains a null character",
repository.getPath()));
}
} else {
throw new IOException(format(
"The repository [%s] is not a directory",
repository.getAbsolutePath()));
}
}
OutputStream output = getOutputStream();
if (cachedContent != null) {
output.write(cachedContent);
} else {
FileInputStream input = new FileInputStream(dfosFile);
IOUtils.copy(input, output);
dfosFile.delete();
dfosFile = null;
}
output.close();
cachedContent = null;
}
/**
* Returns the file item headers.
* @return The file items headers.
*/
public FileItemHeaders getHeaders() {
return headers;
}
/**
* Sets the file item headers.
* @param pHeaders The file items headers.
*/
public void setHeaders(FileItemHeaders pHeaders) {
headers = pHeaders;
}
}
././@LongLink 100644 0 0 147 12274740161 10261 L ustar 0 0 commons-fileupload-1.3.1-src/src/main/java/org/apache/commons/fileupload/disk/DiskFileItemFactory.java commons-fileupload-1.3.1-src/src/main/java/org/apache/commons/fileupload/disk/DiskFileItemFactory.ja100644 0 0 21125 12274737402 30630 0 ustar 0 0 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.disk;
import java.io.File;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileItemFactory;
import org.apache.commons.io.FileCleaningTracker;
/**
*
The default {@link org.apache.commons.fileupload.FileItemFactory} * implementation. This implementation creates * {@link org.apache.commons.fileupload.FileItem} instances which keep their * content either in memory, for smaller items, or in a temporary file on disk, * for larger items. The size threshold, above which content will be stored on * disk, is configurable, as is the directory in which temporary files will be * created.
* *If not otherwise configured, the default configuration values are as * follows:
*-
*
- Size threshold is 10KB. *
- Repository is the system default temp directory, as returned by
*
System.getProperty("java.io.tmpdir").
*
* NOTE: Files are created in the system default temp directory with
* predictable names. This means that a local attacker with write access to that
* directory can perform a TOUTOC attack to replace any uploaded file with a
* file of the attackers choice. The implications of this will depend on how the
* uploaded file is used but could be significant. When using this
* implementation in an environment with local, untrusted users,
* {@link #setRepository(File)} MUST be used to configure a repository location
* that is not publicly writable. In a Servlet container the location identified
* by the ServletContext attribute javax.servlet.context.tempdir
* may be used.
*
Temporary files, which are created for file items, should be * deleted later on. The best way to do this is using a * {@link FileCleaningTracker}, which you can set on the * {@link DiskFileItemFactory}. However, if you do use such a tracker, * then you must consider the following: Temporary files are automatically * deleted as soon as they are no longer needed. (More precisely, when the * corresponding instance of {@link java.io.File} is garbage collected.) * This is done by the so-called reaper thread, which is started and stopped * automatically by the {@link FileCleaningTracker} when there are files to be * tracked. * It might make sense to terminate that thread, for example, if * your web application ends. See the section on "Resource cleanup" * in the users guide of commons-fileupload.
* * @since FileUpload 1.1 * * @version $Id: DiskFileItemFactory.java 1564788 2014-02-05 14:36:41Z markt $ */ public class DiskFileItemFactory implements FileItemFactory { // ----------------------------------------------------- Manifest constants /** * The default threshold above which uploads will be stored on disk. */ public static final int DEFAULT_SIZE_THRESHOLD = 10240; // ----------------------------------------------------- Instance Variables /** * The directory in which uploaded files will be stored, if stored on disk. */ private File repository; /** * The threshold above which uploads will be stored on disk. */ private int sizeThreshold = DEFAULT_SIZE_THRESHOLD; /** *The instance of {@link FileCleaningTracker}, which is responsible * for deleting temporary files.
*May be null, if tracking files is not required.
*/ private FileCleaningTracker fileCleaningTracker; // ----------------------------------------------------------- Constructors /** * Constructs an unconfigured instance of this class. The resulting factory * may be configured by calling the appropriate setter methods. */ public DiskFileItemFactory() { this(DEFAULT_SIZE_THRESHOLD, null); } /** * Constructs a preconfigured instance of this class. * * @param sizeThreshold The threshold, in bytes, below which items will be * retained in memory and above which they will be * stored as a file. * @param repository The data repository, which is the directory in * which files will be created, should the item size * exceed the threshold. */ public DiskFileItemFactory(int sizeThreshold, File repository) { this.sizeThreshold = sizeThreshold; this.repository = repository; } // ------------------------------------------------------------- Properties /** * Returns the directory used to temporarily store files that are larger * than the configured size threshold. * * @return The directory in which temporary files will be located. * * @see #setRepository(java.io.File) * */ public File getRepository() { return repository; } /** * Sets the directory used to temporarily store files that are larger * than the configured size threshold. * * @param repository The directory in which temporary files will be located. * * @see #getRepository() * */ public void setRepository(File repository) { this.repository = repository; } /** * Returns the size threshold beyond which files are written directly to * disk. The default value is 10240 bytes. * * @return The size threshold, in bytes. * * @see #setSizeThreshold(int) */ public int getSizeThreshold() { return sizeThreshold; } /** * Sets the size threshold beyond which files are written directly to disk. * * @param sizeThreshold The size threshold, in bytes. * * @see #getSizeThreshold() * */ public void setSizeThreshold(int sizeThreshold) { this.sizeThreshold = sizeThreshold; } // --------------------------------------------------------- Public Methods /** * Create a new {@link org.apache.commons.fileupload.disk.DiskFileItem} * instance from the supplied parameters and the local factory * configuration. * * @param fieldName The name of the form field. * @param contentType The content type of the form field. * @param isFormFieldtrue if this is a plain form field;
* false otherwise.
* @param fileName The name of the uploaded file, if any, as supplied
* by the browser or other client.
*
* @return The newly created file item.
*/
public FileItem createItem(String fieldName, String contentType,
boolean isFormField, String fileName) {
DiskFileItem result = new DiskFileItem(fieldName, contentType,
isFormField, fileName, sizeThreshold, repository);
FileCleaningTracker tracker = getFileCleaningTracker();
if (tracker != null) {
tracker.track(result.getTempFile(), result);
}
return result;
}
/**
* Returns the tracker, which is responsible for deleting temporary
* files.
*
* @return An instance of {@link FileCleaningTracker}, or null
* (default), if temporary files aren't tracked.
*/
public FileCleaningTracker getFileCleaningTracker() {
return fileCleaningTracker;
}
/**
* Sets the tracker, which is responsible for deleting temporary
* files.
*
* @param pTracker An instance of {@link FileCleaningTracker},
* which will from now on track the created files, or null
* (default), to disable tracking.
*/
public void setFileCleaningTracker(FileCleaningTracker pTracker) {
fileCleaningTracker = pTracker;
}
}
commons-fileupload-1.3.1-src/src/main/java/org/apache/commons/fileupload/disk/package-info.java 100644 0 0 4630 12274737402 27624 0 ustar 0 0 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*/
/**
* * A disk-based implementation of the * {@link org.apache.commons.fileupload.FileItem FileItem} * interface. This implementation retains smaller items in memory, while * writing larger ones to disk. The threshold between these two is * configurable, as is the location of files that are written to disk. *
** In typical usage, an instance of * {@link org.apache.commons.fileupload.disk.DiskFileItemFactory DiskFileItemFactory} * would be created, configured, and then passed to a * {@link org.apache.commons.fileupload.FileUpload FileUpload} * implementation such as * {@link org.apache.commons.fileupload.servlet.ServletFileUpload ServletFileUpload} * or * {@link org.apache.commons.fileupload.portlet.PortletFileUpload PortletFileUpload}. *
** The following code fragment demonstrates this usage. *
*
* DiskFileItemFactory factory = new DiskFileItemFactory();
* // maximum size that will be stored in memory
* factory.setSizeThreshold(4096);
* // the location for saving data that is larger than getSizeThreshold()
* factory.setRepository(new File("/tmp"));
*
* ServletFileUpload upload = new ServletFileUpload(factory);
*
* * Please see the FileUpload * User Guide * for further details and examples of how to use this package. *
*/ package org.apache.commons.fileupload.disk; commons-fileupload-1.3.1-src/src/main/java/org/apache/commons/fileupload/DiskFileUpload.java 100644 0 0 16121 12274737401 27222 0 ustar 0 0 /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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.File; import java.util.List; import javax.servlet.http.HttpServletRequest; /** *High level API for processing file uploads.
* *This class handles multiple files per single HTML widget, sent using
* multipart/mixed encoding type, as specified by
* RFC 1867. Use {@link
* #parseRequest(HttpServletRequest)} to acquire a list of {@link
* org.apache.commons.fileupload.FileItem}s associated with a given HTML
* widget.
Individual parts will be stored in temporary disk storage or in memory, * depending on their size, and will be available as {@link * org.apache.commons.fileupload.FileItem}s.
* * @version $Id: DiskFileUpload.java 1454690 2013-03-09 12:08:48Z simonetripodi $ * * @deprecated 1.1 UseServletFileUpload together with
* DiskFileItemFactory instead.
*/
@Deprecated
public class DiskFileUpload
extends FileUploadBase {
// ----------------------------------------------------------- Data members
/**
* The factory to use to create new form items.
*/
private DefaultFileItemFactory fileItemFactory;
// ----------------------------------------------------------- Constructors
/**
* Constructs an instance of this class which uses the default factory to
* create FileItem instances.
*
* @see #DiskFileUpload(DefaultFileItemFactory fileItemFactory)
*
* @deprecated 1.1 Use FileUpload instead.
*/
@Deprecated
public DiskFileUpload() {
super();
this.fileItemFactory = new DefaultFileItemFactory();
}
/**
* Constructs an instance of this class which uses the supplied factory to
* create FileItem instances.
*
* @see #DiskFileUpload()
* @param fileItemFactory The file item factory to use.
*
* @deprecated 1.1 Use FileUpload instead.
*/
@Deprecated
public DiskFileUpload(DefaultFileItemFactory fileItemFactory) {
super();
this.fileItemFactory = fileItemFactory;
}
// ----------------------------------------------------- Property accessors
/**
* Returns the factory class used when creating file items.
*
* @return The factory class for new file items.
*
* @deprecated 1.1 Use FileUpload instead.
*/
@Override
@Deprecated
public FileItemFactory getFileItemFactory() {
return fileItemFactory;
}
/**
* Sets the factory class to use when creating file items. The factory must
* be an instance of DefaultFileItemFactory or a subclass
* thereof, or else a ClassCastException will be thrown.
*
* @param factory The factory class for new file items.
*
* @deprecated 1.1 Use FileUpload instead.
*/
@Override
@Deprecated
public void setFileItemFactory(FileItemFactory factory) {
this.fileItemFactory = (DefaultFileItemFactory) factory;
}
/**
* Returns the size threshold beyond which files are written directly to
* disk.
*
* @return The size threshold, in bytes.
*
* @see #setSizeThreshold(int)
*
* @deprecated 1.1 Use DiskFileItemFactory instead.
*/
@Deprecated
public int getSizeThreshold() {
return fileItemFactory.getSizeThreshold();
}
/**
* Sets the size threshold beyond which files are written directly to disk.
*
* @param sizeThreshold The size threshold, in bytes.
*
* @see #getSizeThreshold()
*
* @deprecated 1.1 Use DiskFileItemFactory instead.
*/
@Deprecated
public void setSizeThreshold(int sizeThreshold) {
fileItemFactory.setSizeThreshold(sizeThreshold);
}
/**
* Returns the location used to temporarily store files that are larger
* than the configured size threshold.
*
* @return The path to the temporary file location.
*
* @see #setRepositoryPath(String)
*
* @deprecated 1.1 Use DiskFileItemFactory instead.
*/
@Deprecated
public String getRepositoryPath() {
return fileItemFactory.getRepository().getPath();
}
/**
* Sets the location used to temporarily store files that are larger
* than the configured size threshold.
*
* @param repositoryPath The path to the temporary file location.
*
* @see #getRepositoryPath()
*
* @deprecated 1.1 Use DiskFileItemFactory instead.
*/
@Deprecated
public void setRepositoryPath(String repositoryPath) {
fileItemFactory.setRepository(new File(repositoryPath));
}
// --------------------------------------------------------- Public methods
/**
* Processes an RFC 1867
* compliant multipart/form-data stream. If files are stored
* on disk, the path is given by getRepository().
*
* @param req The servlet request to be parsed. Must be non-null.
* @param sizeThreshold The max size in bytes to be stored in memory.
* @param sizeMax The maximum allowed upload size, in bytes.
* @param path The location where the files should be stored.
*
* @return A list of FileItem instances parsed from the
* request, in the order that they were transmitted.
*
* @throws FileUploadException if there are problems reading/parsing
* the request or storing files.
*
* @deprecated 1.1 Use ServletFileUpload instead.
*/
@Deprecated
public List This class represents a file or form item that was received within a
* multipart/form-data POST request.
*
*
After retrieving an instance of this class from a {@link * org.apache.commons.fileupload.FileUpload FileUpload} instance (see * {@link org.apache.commons.fileupload.servlet.ServletFileUpload * #parseRequest(javax.servlet.http.HttpServletRequest)}), you may * either request all contents of the file at once using {@link #get()} or * request an {@link java.io.InputStream InputStream} with * {@link #getInputStream()} and process the file without attempting to load * it into memory, which may come handy with large files. * *
While this interface does not extend
* javax.activation.DataSource per se (to avoid a seldom used
* dependency), several of the defined methods are specifically defined with
* the same signatures as methods in that interface. This allows an
* implementation of this interface to also implement
* javax.activation.DataSource with minimal additional work.
*
* @version $Id: FileItem.java 1454690 2013-03-09 12:08:48Z simonetripodi $
* @since 1.3 additionally implements FileItemHeadersSupport
*/
public interface FileItem extends Serializable, FileItemHeadersSupport {
// ------------------------------- Methods from javax.activation.DataSource
/**
* Returns an {@link java.io.InputStream InputStream} that can be
* used to retrieve the contents of the file.
*
* @return An {@link java.io.InputStream InputStream} that can be
* used to retrieve the contents of the file.
*
* @throws IOException if an error occurs.
*/
InputStream getInputStream() throws IOException;
/**
* Returns the content type passed by the browser or null if
* not defined.
*
* @return The content type passed by the browser or null if
* not defined.
*/
String getContentType();
/**
* Returns the original filename in the client's filesystem, as provided by
* the browser (or other client software). In most cases, this will be the
* base file name, without path information. However, some clients, such as
* the Opera browser, do include path information.
*
* @return The original filename in the client's filesystem.
* @throws InvalidFileNameException The file name contains a NUL character,
* which might be an indicator of a security attack. If you intend to
* use the file name anyways, catch the exception and use
* InvalidFileNameException#getName().
*/
String getName();
// ------------------------------------------------------- FileItem methods
/**
* Provides a hint as to whether or not the file contents will be read
* from memory.
*
* @return true if the file contents will be read from memory;
* false otherwise.
*/
boolean isInMemory();
/**
* Returns the size of the file item.
*
* @return The size of the file item, in bytes.
*/
long getSize();
/**
* Returns the contents of the file item as an array of bytes.
*
* @return The contents of the file item as an array of bytes.
*/
byte[] get();
/**
* Returns the contents of the file item as a String, using the specified
* encoding. This method uses {@link #get()} to retrieve the
* contents of the item.
*
* @param encoding The character encoding to use.
*
* @return The contents of the item, as a string.
*
* @throws UnsupportedEncodingException if the requested character
* encoding is not available.
*/
String getString(String encoding) throws UnsupportedEncodingException;
/**
* Returns the contents of the file item as a String, using the default
* character encoding. This method uses {@link #get()} to retrieve the
* contents of the item.
*
* @return The contents of the item, as a string.
*/
String getString();
/**
* A convenience method to write an uploaded item to disk. The client code
* is not concerned with whether or not the item is stored in memory, or on
* disk in a temporary location. They just want to write the uploaded item
* to a file.
*
* This method is not guaranteed to succeed if called more than once for
* the same item. This allows a particular implementation to use, for
* example, file renaming, where possible, rather than copying all of the
* underlying data, thus gaining a significant performance benefit.
*
* @param file The File into which the uploaded item should
* be stored.
*
* @throws Exception if an error occurs.
*/
void write(File file) throws Exception;
/**
* Deletes the underlying storage for a file item, including deleting any
* associated temporary disk file. Although this storage will be deleted
* automatically when the FileItem instance is garbage
* collected, this method can be used to ensure that this is done at an
* earlier time, thus preserving system resources.
*/
void delete();
/**
* Returns the name of the field in the multipart form corresponding to
* this file item.
*
* @return The name of the form field.
*/
String getFieldName();
/**
* Sets the field name used to reference this file item.
*
* @param name The name of the form field.
*/
void setFieldName(String name);
/**
* Determines whether or not a FileItem instance represents
* a simple form field.
*
* @return true if the instance represents a simple form
* field; false if it represents an uploaded file.
*/
boolean isFormField();
/**
* Specifies whether or not a FileItem instance represents
* a simple form field.
*
* @param state true if the instance represents a simple form
* field; false if it represents an uploaded file.
*/
void setFormField(boolean state);
/**
* Returns an {@link java.io.OutputStream OutputStream} that can
* be used for storing the contents of the file.
*
* @return An {@link java.io.OutputStream OutputStream} that can be used
* for storing the contensts of the file.
*
* @throws IOException if an error occurs.
*/
OutputStream getOutputStream() throws IOException;
}
commons-fileupload-1.3.1-src/src/main/java/org/apache/commons/fileupload/FileItemFactory.java 100644 0 0 3655 12274737401 27401 0 ustar 0 0 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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;
/**
*
A factory interface for creating {@link FileItem} instances. Factories * can provide their own custom configuration, over and above that provided * by the default file upload implementation.
* * @version $Id: FileItemFactory.java 1454690 2013-03-09 12:08:48Z simonetripodi $ */ public interface FileItemFactory { /** * Create a new {@link FileItem} instance from the supplied parameters and * any local factory configuration. * * @param fieldName The name of the form field. * @param contentType The content type of the form field. * @param isFormFieldtrue if this is a plain form field;
* false otherwise.
* @param fileName The name of the uploaded file, if any, as supplied
* by the browser or other client.
*
* @return The newly created file item.
*/
FileItem createItem(
String fieldName,
String contentType,
boolean isFormField,
String fileName
);
}
commons-fileupload-1.3.1-src/src/main/java/org/apache/commons/fileupload/FileItemHeaders.java 100644 0 0 5546 12274737401 27346 0 ustar 0 0 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.util.Iterator;
/**
* This class provides support for accessing the headers for a file or form
* item that was received within a multipart/form-data POST
* request.
String.
*
* If the part did not include a header of the specified name, this method
* return null. If there are multiple headers with the same
* name, this method returns the first header in the item. The header
* name is case insensitive.
*
* @param name a String specifying the header name
* @return a String containing the value of the requested
* header, or null if the item does not have a header
* of that name
*/
String getHeader(String name);
/**
*
* Returns all the values of the specified item header as an
* Iterator of String objects.
*
* If the item did not include any headers of the specified name, this
* method returns an empty Iterator. The header name is
* case insensitive.
*
String specifying the header name
* @return an Iterator containing the values of the
* requested header. If the item does not have any headers of
* that name, return an empty Iterator
*/
Iterator
* Returns an Iterator of all the header names.
*
Iterator containing all of the names of
* headers provided with this file item. If the item does not have
* any headers return an empty Iterator
*/
Iterator This interface provides access to a file or form item that was
* received within a multipart/form-data POST request.
* The items contents are retrieved by calling {@link #openStream()}.
Instances of this class are created by accessing the * iterator, returned by * {@link FileUploadBase#getItemIterator(RequestContext)}.
*Note: There is an interaction between the iterator and * its associated instances of {@link FileItemStream}: By invoking * {@link java.util.Iterator#hasNext()} on the iterator, you discard all data, * which hasn't been read so far from the previous data.
* * @version $Id: FileItemStream.java 1454691 2013-03-09 12:15:54Z simonetripodi $ */ public interface FileItemStream extends FileItemHeadersSupport { /** * This exception is thrown, if an attempt is made to read * data from the {@link InputStream}, which has been returned * by {@link FileItemStream#openStream()}, after * {@link java.util.Iterator#hasNext()} has been invoked on the * iterator, which created the {@link FileItemStream}. */ public static class ItemSkippedException extends IOException { /** * The exceptions serial version UID, which is being used * when serializing an exception instance. */ private static final long serialVersionUID = -7280778431581963740L; } /** * Creates an {@link InputStream}, which allows to read the * items contents. * * @return The input stream, from which the items data may * be read. * @throws IllegalStateException The method was already invoked on * this item. It is not possible to recreate the data stream. * @throws IOException An I/O error occurred. * @see ItemSkippedException */ InputStream openStream() throws IOException; /** * Returns the content type passed by the browser ornull if
* not defined.
*
* @return The content type passed by the browser or null if
* not defined.
*/
String getContentType();
/**
* Returns the original filename in the client's filesystem, as provided by
* the browser (or other client software). In most cases, this will be the
* base file name, without path information. However, some clients, such as
* the Opera browser, do include path information.
*
* @return The original filename in the client's filesystem.
*/
String getName();
/**
* Returns the name of the field in the multipart form corresponding to
* this file item.
*
* @return The name of the form field.
*/
String getFieldName();
/**
* Determines whether or not a FileItem instance represents
* a simple form field.
*
* @return true if the instance represents a simple form
* field; false if it represents an uploaded file.
*/
boolean isFormField();
}
commons-fileupload-1.3.1-src/src/main/java/org/apache/commons/fileupload/FileUpload.java 100644 0 0 6247 12274737401 26377 0 ustar 0 0 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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;
/**
* High level API for processing file uploads.
* *This class handles multiple files per single HTML widget, sent using
* multipart/mixed encoding type, as specified by
* RFC 1867. Use {@link
* #parseRequest(RequestContext)} to acquire a list
* of {@link org.apache.commons.fileupload.FileItem FileItems} associated
* with a given HTML widget.
How the data for individual parts is stored is determined by the factory * used to create them; a given part may be in memory, on disk, or somewhere * else.
* * @version $Id: FileUpload.java 1454690 2013-03-09 12:08:48Z simonetripodi $ */ public class FileUpload extends FileUploadBase { // ----------------------------------------------------------- Data members /** * The factory to use to create new form items. */ private FileItemFactory fileItemFactory; // ----------------------------------------------------------- Constructors /** * Constructs an uninitialised instance of this class. * * A factory must be * configured, usingsetFileItemFactory(), before attempting
* to parse requests.
*
* @see #FileUpload(FileItemFactory)
*/
public FileUpload() {
super();
}
/**
* Constructs an instance of this class which uses the supplied factory to
* create FileItem instances.
*
* @see #FileUpload()
* @param fileItemFactory The factory to use for creating file items.
*/
public FileUpload(FileItemFactory fileItemFactory) {
super();
this.fileItemFactory = fileItemFactory;
}
// ----------------------------------------------------- Property accessors
/**
* Returns the factory class used when creating file items.
*
* @return The factory class for new file items.
*/
@Override
public FileItemFactory getFileItemFactory() {
return fileItemFactory;
}
/**
* Sets the factory class to use when creating file items.
*
* @param factory The factory class for new file items.
*/
@Override
public void setFileItemFactory(FileItemFactory factory) {
this.fileItemFactory = factory;
}
}
commons-fileupload-1.3.1-src/src/main/java/org/apache/commons/fileupload/FileUploadBase.java 100644 0 0 150132 12274737401 27223 0 ustar 0 0 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 static java.lang.String.format;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.NoSuchElementException;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.fileupload.MultipartStream.ItemInputStream;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.commons.fileupload.servlet.ServletRequestContext;
import org.apache.commons.fileupload.util.Closeable;
import org.apache.commons.fileupload.util.FileItemHeadersImpl;
import org.apache.commons.fileupload.util.LimitedInputStream;
import org.apache.commons.fileupload.util.Streams;
/**
* High level API for processing file uploads.
* *This class handles multiple files per single HTML widget, sent using
* multipart/mixed encoding type, as specified by
* RFC 1867. Use {@link
* #parseRequest(RequestContext)} to acquire a list of {@link
* org.apache.commons.fileupload.FileItem}s associated with a given HTML
* widget.
How the data for individual parts is stored is determined by the factory * used to create them; a given part may be in memory, on disk, or somewhere * else.
* * @version $Id: FileUploadBase.java 1565194 2014-02-06 12:16:30Z markt $ */ public abstract class FileUploadBase { // ---------------------------------------------------------- Class methods /** *Utility method that determines whether the request contains multipart * content.
* *NOTE:This method will be moved to the
* ServletFileUpload class after the FileUpload 1.1 release.
* Unfortunately, since this method is static, it is not possible to
* provide its replacement until this method is removed.
true if the request is multipart;
* false otherwise.
*/
public static final boolean isMultipartContent(RequestContext ctx) {
String contentType = ctx.getContentType();
if (contentType == null) {
return false;
}
if (contentType.toLowerCase(Locale.ENGLISH).startsWith(MULTIPART)) {
return true;
}
return false;
}
/**
* Utility method that determines whether the request contains multipart
* content.
*
* @param req The servlet request to be evaluated. Must be non-null.
*
* @return true if the request is multipart;
* false otherwise.
*
* @deprecated 1.1 Use the method on ServletFileUpload instead.
*/
@Deprecated
public static boolean isMultipartContent(HttpServletRequest req) {
return ServletFileUpload.isMultipartContent(req);
}
// ----------------------------------------------------- Manifest constants
/**
* HTTP content type header name.
*/
public static final String CONTENT_TYPE = "Content-type";
/**
* HTTP content disposition header name.
*/
public static final String CONTENT_DISPOSITION = "Content-disposition";
/**
* HTTP content length header name.
*/
public static final String CONTENT_LENGTH = "Content-length";
/**
* Content-disposition value for form data.
*/
public static final String FORM_DATA = "form-data";
/**
* Content-disposition value for file attachment.
*/
public static final String ATTACHMENT = "attachment";
/**
* Part of HTTP content type header.
*/
public static final String MULTIPART = "multipart/";
/**
* HTTP content type header for multipart forms.
*/
public static final String MULTIPART_FORM_DATA = "multipart/form-data";
/**
* HTTP content type header for multiple uploads.
*/
public static final String MULTIPART_MIXED = "multipart/mixed";
/**
* The maximum length of a single header line that will be parsed
* (1024 bytes).
* @deprecated This constant is no longer used. As of commons-fileupload
* 1.2, the only applicable limit is the total size of a parts headers,
* {@link MultipartStream#HEADER_PART_SIZE_MAX}.
*/
@Deprecated
public static final int MAX_HEADER_SIZE = 1024;
// ----------------------------------------------------------- Data members
/**
* The maximum size permitted for the complete request, as opposed to
* {@link #fileSizeMax}. A value of -1 indicates no maximum.
*/
private long sizeMax = -1;
/**
* The maximum size permitted for a single uploaded file, as opposed
* to {@link #sizeMax}. A value of -1 indicates no maximum.
*/
private long fileSizeMax = -1;
/**
* The content encoding to use when reading part headers.
*/
private String headerEncoding;
/**
* The progress listener.
*/
private ProgressListener listener;
// ----------------------------------------------------- Property accessors
/**
* Returns the factory class used when creating file items.
*
* @return The factory class for new file items.
*/
public abstract FileItemFactory getFileItemFactory();
/**
* Sets the factory class to use when creating file items.
*
* @param factory The factory class for new file items.
*/
public abstract void setFileItemFactory(FileItemFactory factory);
/**
* Returns the maximum allowed size of a complete request, as opposed
* to {@link #getFileSizeMax()}.
*
* @return The maximum allowed size, in bytes. The default value of
* -1 indicates, that there is no limit.
*
* @see #setSizeMax(long)
*
*/
public long getSizeMax() {
return sizeMax;
}
/**
* Sets the maximum allowed size of a complete request, as opposed
* to {@link #setFileSizeMax(long)}.
*
* @param sizeMax The maximum allowed size, in bytes. The default value of
* -1 indicates, that there is no limit.
*
* @see #getSizeMax()
*
*/
public void setSizeMax(long sizeMax) {
this.sizeMax = sizeMax;
}
/**
* Returns the maximum allowed size of a single uploaded file,
* as opposed to {@link #getSizeMax()}.
*
* @see #setFileSizeMax(long)
* @return Maximum size of a single uploaded file.
*/
public long getFileSizeMax() {
return fileSizeMax;
}
/**
* Sets the maximum allowed size of a single uploaded file,
* as opposed to {@link #getSizeMax()}.
*
* @see #getFileSizeMax()
* @param fileSizeMax Maximum size of a single uploaded file.
*/
public void setFileSizeMax(long fileSizeMax) {
this.fileSizeMax = fileSizeMax;
}
/**
* Retrieves the character encoding used when reading the headers of an
* individual part. When not specified, or null, the request
* encoding is used. If that is also not specified, or null,
* 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 part. When not specified, or null, the request
* encoding is used. If that is also not specified, or null,
* the platform default encoding is used.
*
* @param encoding The encoding used to read part headers.
*/
public void setHeaderEncoding(String encoding) {
headerEncoding = encoding;
}
// --------------------------------------------------------- Public methods
/**
* Processes an RFC 1867
* compliant multipart/form-data stream.
*
* @param req The servlet request to be parsed.
*
* @return A list of FileItem instances parsed from the
* request, in the order that they were transmitted.
*
* @throws FileUploadException if there are problems reading/parsing
* the request or storing files.
*
* @deprecated 1.1 Use {@link ServletFileUpload#parseRequest(HttpServletRequest)} instead.
*/
@Deprecated
public Listmultipart/form-data stream.
*
* @param ctx The context for the request to be parsed.
*
* @return An iterator to instances of FileItemStream
* parsed from the request, in the order that they were
* transmitted.
*
* @throws FileUploadException if there are problems reading/parsing
* the request or storing files.
* @throws IOException An I/O error occurred. This may be a network
* error while communicating with the client or a problem while
* storing the uploaded content.
*/
public FileItemIterator getItemIterator(RequestContext ctx)
throws FileUploadException, IOException {
try {
return new FileItemIteratorImpl(ctx);
} catch (FileUploadIOException e) {
// unwrap encapsulated SizeException
throw (FileUploadException) e.getCause();
}
}
/**
* Processes an RFC 1867
* compliant multipart/form-data stream.
*
* @param ctx The context for the request to be parsed.
*
* @return A list of FileItem instances parsed from the
* request, in the order that they were transmitted.
*
* @throws FileUploadException if there are problems reading/parsing
* the request or storing files.
*/
public Listmultipart/form-data stream.
*
* @param ctx The context for the request to be parsed.
*
* @return A map of FileItem instances parsed from the request.
*
* @throws FileUploadException if there are problems reading/parsing
* the request or storing files.
*
* @since 1.3
*/
public MapContent-type header.
*
* @param contentType The value of the content type header from which to
* extract the boundary value.
*
* @return The boundary, as a byte array.
*/
protected byte[] getBoundary(String contentType) {
ParameterParser parser = new ParameterParser();
parser.setLowerCaseNames(true);
// Parameter parser can handle null input
MapContent-disposition
* header.
*
* @param headers A Map containing the HTTP request headers.
*
* @return The file name for the current encapsulation.
* @deprecated 1.2.1 Use {@link #getFileName(FileItemHeaders)}.
*/
@Deprecated
protected String getFileName(MapContent-disposition
* header.
*
* @param headers The HTTP headers object.
*
* @return The file name for the current encapsulation.
*/
protected String getFileName(FileItemHeaders headers) {
return getFileName(headers.getHeader(CONTENT_DISPOSITION));
}
/**
* Returns the given content-disposition headers file name.
* @param pContentDisposition The content-disposition headers value.
* @return The file name
*/
private String getFileName(String pContentDisposition) {
String fileName = null;
if (pContentDisposition != null) {
String cdl = pContentDisposition.toLowerCase(Locale.ENGLISH);
if (cdl.startsWith(FORM_DATA) || cdl.startsWith(ATTACHMENT)) {
ParameterParser parser = new ParameterParser();
parser.setLowerCaseNames(true);
// Parameter parser can handle null input
MapContent-disposition
* header.
*
* @param headers A Map containing the HTTP request headers.
*
* @return The field name for the current encapsulation.
*/
protected String getFieldName(FileItemHeaders headers) {
return getFieldName(headers.getHeader(CONTENT_DISPOSITION));
}
/**
* Returns the field name, which is given by the content-disposition
* header.
* @param pContentDisposition The content-dispositions header value.
* @return The field jake
*/
private String getFieldName(String pContentDisposition) {
String fieldName = null;
if (pContentDisposition != null
&& pContentDisposition.toLowerCase(Locale.ENGLISH).startsWith(FORM_DATA)) {
ParameterParser parser = new ParameterParser();
parser.setLowerCaseNames(true);
// Parameter parser can handle null input
MapContent-disposition
* header.
*
* @param headers A Map containing the HTTP request headers.
*
* @return The field name for the current encapsulation.
* @deprecated 1.2.1 Use {@link #getFieldName(FileItemHeaders)}.
*/
@Deprecated
protected String getFieldName(MapMap containing the HTTP request
* headers.
* @param isFormField Whether or not this item is a form field, as
* opposed to a file.
*
* @return A newly created FileItem instance.
*
* @throws FileUploadException if an error occurs.
* @deprecated 1.2 This method is no longer used in favour of
* internally created instances of {@link FileItem}.
*/
@Deprecated
protected FileItem createItem(Map Parses the header-part and returns as key/value
* pairs.
*
*
If there are multiple headers of the same names, the name
* will map to a comma-separated list containing the values.
*
* @param headerPart The header-part of the current
* encapsulation.
*
* @return A Map containing the parsed HTTP request headers.
*/
protected FileItemHeaders getParsedHeaders(String headerPart) {
final int len = headerPart.length();
FileItemHeadersImpl headers = newFileItemHeaders();
int start = 0;
for (;;) {
int end = parseEndOfLine(headerPart, start);
if (start == end) {
break;
}
StringBuilder header = new StringBuilder(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.append(" ").append(headerPart.substring(nonWs, end));
start = end + 2;
}
parseHeaderLine(headers, header.toString());
}
return headers;
}
/**
* Creates a new instance of {@link FileItemHeaders}.
* @return The new instance.
*/
protected FileItemHeadersImpl newFileItemHeaders() {
return new FileItemHeadersImpl();
}
/**
*
Parses the header-part and returns as key/value
* pairs.
*
*
If there are multiple headers of the same names, the name
* will map to a comma-separated list containing the values.
*
* @param headerPart The Low level API for processing file uploads.
*
* 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.
*
* The format of the stream is defined in the following way: 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[])}).
*
* Here is an example of usage of this class. Constructs a 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 Constructs a 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 Constructs a Constructs a 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 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 Reads the Headers are returned verbatim to the input stream, including the
* trailing TODO allow limiting maximum header size to
* protect against abuse.
*
* @return The Reads Arbitrary large amounts of data can be processed by this
* method using a constant size buffer. (see {@link
* #MultipartStream(InputStream,byte[],int,
* MultipartStream.ProgressNotifier) constructor}).
*
* @param output The Reads Use this method to skip encapsulations you don't need or don't
* understand.
*
* @return The amount of data discarded.
*
* @throws MalformedStreamException if the stream ends unexpectedly.
* @throws IOException if an i/o error occurs.
*/
public int discardBodyData() throws MalformedStreamException, IOException {
return readBodyData(null);
}
/**
* Finds the beginning of the first
* A component for handling HTML file uploads as specified by
* RFC 1867.
* This component provides support for uploads within both servlets (JSR 53)
* and portlets (JSR 168).
*
* While this package provides the generic functionality for file uploads,
* these classes are not typically used directly. Instead, normal usage
* involves one of the provided extensions of
* {@link org.apache.commons.fileupload.FileUpload FileUpload} such as
* {@link org.apache.commons.fileupload.servlet.ServletFileUpload ServletFileUpload}
* or
* {@link org.apache.commons.fileupload.portlet.PortletFileUpload PortletFileUpload},
* together with a factory for
* {@link org.apache.commons.fileupload.FileItem FileItem} instances,
* such as
* {@link org.apache.commons.fileupload.disk.DiskFileItemFactory DiskFileItemFactory}.
*
* The following is a brief example of typical usage in a servlet, storing
* the uploaded files on disk.
*
* In the example above, the first file is loaded into memory as a
*
* Please see the FileUpload
* User Guide
* for further details and examples of how to use this package.
*
*
* An implementation of
* {@link org.apache.commons.fileupload.FileUpload FileUpload}
* for use in portlets conforming to JSR 168. This implementation requires
* only access to the portlet's current
* The following code fragment demonstrates typical usage.
*
* Please see the FileUpload
* User Guide
* for further details and examples of how to use this package.
* High level API for processing file uploads. This class handles multiple files per single HTML widget, sent using
* How the data for individual parts is stored is determined by the factory
* used to create them; a given part may be in memory, on disk, or somewhere
* else. Provides access to the request information needed for a request made to
* a portlet. Abstracts access to the request information needed for file uploads. This
* interface should be implemented for each type of request that may be
* handled by FileUpload, such as servlets and portlets.
* An implementation of
* {@link org.apache.commons.fileupload.FileUpload FileUpload}
* for use in servlets conforming to JSR 53. This implementation requires
* only access to the servlet's current
* The following code fragment demonstrates typical usage.
*
* Please see the FileUpload
* User Guide
* for further details and examples of how to use this package.
* High level API for processing file uploads. This class handles multiple files per single HTML widget, sent using
* How the data for individual parts is stored is determined by the factory
* used to create them; a given part may be in memory, on disk, or somewhere
* else. Provides access to the request information needed for a request made to
* an HTTP servlet.
* This method
* simply performs
* This method simply performs There are two common causes for this error. Firstly, it might simply mean that you do not have the Commons IO
jar in your classpath. FileUpload depends on IO (see
dependencies) - you can tell if
this is the case if the missing class is within the
Secondly this happens when attempting to rely on a shared copy of
the Commons FileUpload jar file provided by your web container. The
solution is to include the FileUpload jar file as part of your own
web application, instead of relying on the container. The same may
hold for FileUpload's IO dependency.
At least as of version 8, Flash contains a known bug: The multipart
stream it produces is broken, because the final boundary doesn't
contain the suffix "--", which ought to indicate, that no more
items are following. Consequently, FileUpload waits for the next
item (which it doesn't get) and throws an exception.
The problems details and a possible workaround are outlined in
Bug 143
. The workaround suggests to use the streaming API
and catch the exception. The resulting code could look like
this:
TODO: Document usage of factories and subclassing for customization.
We recommend you use a mirror to download our release
builds, but you must verify the integrity of
the downloaded files using signatures downloaded from our main
distribution directories. Recent releases (48 hours) may not yet
be available from the mirrors.
You are currently using [preferred]. If you
encounter a problem with this mirror, please select another
mirror. If all mirrors are failing, there are backup
mirrors (at the end of the mirrors list) that should be
available.
The KEYS
link links to the code signing keys used to sign the product.
The
Older releases can be obtained from the archives.
The Commons FileUpload package makes it easy to add
robust, high-performance, file upload capability to your servlets and
web applications.
FileUpload parses HTTP requests which conform to
RFC 1867,
"Form-based File Upload in HTML". That is, if an HTTP request is
submitted using the POST method, and with a content type of
"multipart/form-data", then FileUpload can parse that request, and
make the results available in a manner easily used by the caller.
Starting with version 1.3, FileUpload handles
RFC 2047 encoded header values.
The simplest way to send a multipart/form-data request to a server is via a web form, i.e. The following documentation is available: You can also browse the Subversion repository. FileUpload 1.3 - 27 March 2013 FileUpload 1.2.2 - 29 July 2010 FileUpload 1.2.1 - 18 January 2008 FileUpload 1.2 - 13 February 2007 FileUpload 1.1.1 - 08 June 2006 FileUpload 1.1 - 22 Dec 2005 FileUpload 1.0 - 24 Jun 2003
None available.
The Apache Commons mailing lists act as
the main support forum. The user list is suitable for most library
usage queries. The dev list is intended for development discussion.
Please remember that the lists are shared between all commons components,
so prefix your e-mail subject line with [fileupload].
Issues may be reported via ASF JIRA.
Commons FileUpload uses ASF JIRA for tracking issues.
See the Commons FileUpload JIRA project page.
To use JIRA you may need to create an account
(if you have previously created/updated Commons issues using Bugzilla an account will have been automatically
created and you can use the Forgot Password
page to get a new password).
If you would like to report a bug, or raise an enhancement request with
Commons FileUpload please do the following:
Please also remember these points:
header-part of the current
* encapsulation.
*
* @return A Map containing the parsed HTTP request headers.
* @deprecated 1.2.1 Use {@link #getParsedHeaders(String)}
*/
@Deprecated
protected MapMap containing the HTTP request headers.
* @param name The name of the header to return.
*
* @return The value of specified header, or a comma-separated list if
* there were multiple headers of that name.
* @deprecated 1.2.1 Use {@link FileItemHeaders#getHeader(String)}.
*/
@Deprecated
protected final String getHeader(MapFileUploadIOException with the
* given cause.
*
* @param pCause The exceptions cause, if any, or null.
*/
public FileUploadIOException(FileUploadException pCause) {
// We're not doing super(pCause) cause of 1.3 compatibility.
cause = pCause;
}
/**
* Returns the exceptions cause.
*
* @return The exceptions cause, if any, or null.
*/
@Override
public Throwable getCause() {
return cause;
}
}
/**
* Thrown to indicate that the request is not a multipart request.
*/
public static class InvalidContentTypeException
extends FileUploadException {
/**
* The exceptions UID, for serializing an instance.
*/
private static final long serialVersionUID = -9073026332015646668L;
/**
* Constructs a InvalidContentTypeException with no
* detail message.
*/
public InvalidContentTypeException() {
super();
}
/**
* Constructs an InvalidContentTypeException with
* the specified detail message.
*
* @param message The detail message.
*/
public InvalidContentTypeException(String message) {
super(message);
}
/**
* Constructs an InvalidContentTypeException with
* the specified detail message and cause.
*
* @param msg The detail message.
* @param cause the original cause
*
* @since 1.3.1
*/
public InvalidContentTypeException(String msg, Throwable cause) {
super(msg, cause);
}
}
/**
* Thrown to indicate an IOException.
*/
public static class IOFileUploadException extends FileUploadException {
/**
* The exceptions UID, for serializing an instance.
*/
private static final long serialVersionUID = 1749796615868477269L;
/**
* The exceptions cause; we overwrite the parent
* classes field, which is available since Java
* 1.4 only.
*/
private final IOException cause;
/**
* Creates a new instance with the given cause.
*
* @param pMsg The detail message.
* @param pException The exceptions cause.
*/
public IOFileUploadException(String pMsg, IOException pException) {
super(pMsg);
cause = pException;
}
/**
* Returns the exceptions cause.
*
* @return The exceptions cause, if any, or null.
*/
@Override
public Throwable getCause() {
return cause;
}
}
/**
* This exception is thrown, if a requests permitted size
* is exceeded.
*/
protected abstract static class SizeException extends FileUploadException {
/**
* Serial version UID, being used, if serialized.
*/
private static final long serialVersionUID = -8776225574705254126L;
/**
* The actual size of the request.
*/
private final long actual;
/**
* The maximum permitted size of the request.
*/
private final long permitted;
/**
* Creates a new instance.
*
* @param message The detail message.
* @param actual The actual number of bytes in the request.
* @param permitted The requests size limit, in bytes.
*/
protected SizeException(String message, long actual, long permitted) {
super(message);
this.actual = actual;
this.permitted = permitted;
}
/**
* Retrieves the actual size of the request.
*
* @return The actual size of the request.
* @since 1.3
*/
public long getActualSize() {
return actual;
}
/**
* Retrieves the permitted size of the request.
*
* @return The permitted size of the request.
* @since 1.3
*/
public long getPermittedSize() {
return permitted;
}
}
/**
* Thrown to indicate that the request size is not specified. In other
* words, it is thrown, if the content-length header is missing or
* contains the value -1.
*
* @deprecated 1.2 As of commons-fileupload 1.2, the presence of a
* content-length header is no longer required.
*/
@Deprecated
public static class UnknownSizeException
extends FileUploadException {
/**
* The exceptions UID, for serializing an instance.
*/
private static final long serialVersionUID = 7062279004812015273L;
/**
* Constructs a UnknownSizeException with no
* detail message.
*/
public UnknownSizeException() {
super();
}
/**
* Constructs an UnknownSizeException with
* the specified detail message.
*
* @param message The detail message.
*/
public UnknownSizeException(String message) {
super(message);
}
}
/**
* Thrown to indicate that the request size exceeds the configured maximum.
*/
public static class SizeLimitExceededException
extends SizeException {
/**
* The exceptions UID, for serializing an instance.
*/
private static final long serialVersionUID = -2474893167098052828L;
/**
* @deprecated 1.2 Replaced by
* {@link #SizeLimitExceededException(String, long, long)}
*/
@Deprecated
public SizeLimitExceededException() {
this(null, 0, 0);
}
/**
* @deprecated 1.2 Replaced by
* {@link #SizeLimitExceededException(String, long, long)}
* @param message The exceptions detail message.
*/
@Deprecated
public SizeLimitExceededException(String message) {
this(message, 0, 0);
}
/**
* Constructs a SizeExceededException with
* the specified detail message, and actual and permitted sizes.
*
* @param message The detail message.
* @param actual The actual request size.
* @param permitted The maximum permitted request size.
*/
public SizeLimitExceededException(String message, long actual,
long permitted) {
super(message, actual, permitted);
}
}
/**
* Thrown to indicate that A files size exceeds the configured maximum.
*/
public static class FileSizeLimitExceededException
extends SizeException {
/**
* The exceptions UID, for serializing an instance.
*/
private static final long serialVersionUID = 8150776562029630058L;
/**
* File name of the item, which caused the exception.
*/
private String fileName;
/**
* Field name of the item, which caused the exception.
*/
private String fieldName;
/**
* Constructs a SizeExceededException with
* the specified detail message, and actual and permitted sizes.
*
* @param message The detail message.
* @param actual The actual request size.
* @param permitted The maximum permitted request size.
*/
public FileSizeLimitExceededException(String message, long actual,
long permitted) {
super(message, actual, permitted);
}
/**
* Returns the file name of the item, which caused the
* exception.
*
* @return File name, if known, or null.
*/
public String getFileName() {
return fileName;
}
/**
* Sets the file name of the item, which caused the
* exception.
*
* @param pFileName the file name of the item, which caused the exception.
*/
public void setFileName(String pFileName) {
fileName = pFileName;
}
/**
* Returns the field name of the item, which caused the
* exception.
*
* @return Field name, if known, or null.
*/
public String getFieldName() {
return fieldName;
}
/**
* Sets the field name of the item, which caused the
* exception.
*
* @param pFieldName the field name of the item,
* which caused the exception.
*/
public void setFieldName(String pFieldName) {
fieldName = pFieldName;
}
}
/**
* Returns the progress listener.
*
* @return The progress listener, if any, or null.
*/
public ProgressListener getProgressListener() {
return listener;
}
/**
* Sets the progress listener.
*
* @param pListener The progress listener, if any. Defaults to null.
*/
public void setProgressListener(ProgressListener pListener) {
listener = pListener;
}
}
commons-fileupload-1.3.1-src/src/main/java/org/apache/commons/fileupload/FileUploadException.java 100644 0 0 6217 12274737401 30253 0 ustar 0 0 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.PrintStream;
import java.io.PrintWriter;
/**
* Exception for errors encountered while processing the request.
*
* @version $Id: FileUploadException.java 1454690 2013-03-09 12:08:48Z simonetripodi $
*/
public class FileUploadException extends Exception {
/**
* Serial version UID, being used, if the exception
* is serialized.
*/
private static final long serialVersionUID = 8881893724388807504L;
/**
* The exceptions cause. We overwrite the cause of
* the super class, which isn't available in Java 1.3.
*/
private final Throwable cause;
/**
* Constructs a new FileUploadException without message.
*/
public FileUploadException() {
this(null, null);
}
/**
* Constructs a new FileUploadException with specified detail
* message.
*
* @param msg the error message.
*/
public FileUploadException(final String msg) {
this(msg, null);
}
/**
* Creates a new FileUploadException with the given
* detail message and cause.
*
* @param msg The exceptions detail message.
* @param cause The exceptions cause.
*/
public FileUploadException(String msg, Throwable cause) {
super(msg);
this.cause = cause;
}
/**
* Prints this throwable and its backtrace to the specified print stream.
*
* @param stream PrintStream to use for output
*/
@Override
public void printStackTrace(PrintStream stream) {
super.printStackTrace(stream);
if (cause != null) {
stream.println("Caused by:");
cause.printStackTrace(stream);
}
}
/**
* Prints this throwable and its backtrace to the specified
* print writer.
*
* @param writer PrintWriter to use for output
*/
@Override
public void printStackTrace(PrintWriter writer) {
super.printStackTrace(writer);
if (cause != null) {
writer.println("Caused by:");
cause.printStackTrace(writer);
}
}
/**
* {@inheritDoc}
*/
@Override
public Throwable getCause() {
return cause;
}
}
././@LongLink 100644 0 0 147 12274740161 10261 L ustar 0 0 commons-fileupload-1.3.1-src/src/main/java/org/apache/commons/fileupload/InvalidFileNameException.java commons-fileupload-1.3.1-src/src/main/java/org/apache/commons/fileupload/InvalidFileNameException.ja100644 0 0 4345 12274737402 30670 0 ustar 0 0 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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;
/**
* This exception is thrown in case of an invalid file name.
* A file name is invalid, if it contains a NUL character.
* Attackers might use this to circumvent security checks:
* For example, a malicious user might upload a file with the name
* "foo.exe\0.png". This file name might pass security checks (i.e.
* checks for the extension ".png"), while, depending on the underlying
* C library, it might create a file named "foo.exe", as the NUL
* character is the string terminator in C.
*
* @version $Id: InvalidFileNameException.java 1454691 2013-03-09 12:15:54Z simonetripodi $
*/
public class InvalidFileNameException extends RuntimeException {
/**
* Serial version UID, being used, if the exception
* is serialized.
*/
private static final long serialVersionUID = 7922042602454350470L;
/**
* The file name causing the exception.
*/
private final String name;
/**
* Creates a new instance.
*
* @param pName The file name causing the exception.
* @param pMessage A human readable error message.
*/
public InvalidFileNameException(String pName, String pMessage) {
super(pMessage);
name = pName;
}
/**
* Returns the invalid file name.
*
* @return the invalid file name.
*/
public String getName() {
return name;
}
}
commons-fileupload-1.3.1-src/src/main/java/org/apache/commons/fileupload/MultipartStream.java 100644 0 0 102566 12274737401 27551 0 ustar 0 0 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 static java.lang.String.format;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import org.apache.commons.fileupload.FileUploadBase.FileUploadIOException;
import org.apache.commons.fileupload.util.Closeable;
import org.apache.commons.fileupload.util.Streams;
/**
*
*
*
* multipart-body := preamble 1*encapsulation close-delimiter epilogue
*
*
* encapsulation := delimiter body CRLF
* delimiter := "--" boundary CRLF
* close-delimiter := "--" boundary "--"
* 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>
*
*
*
* try {
* MultipartStream multipartStream = new MultipartStream(input, boundary);
* boolean nextPart = multipartStream.skipPreamble();
* OutputStream output;
* while(nextPart) {
* String header = multipartStream.readHeaders();
* // process headers
* // create some output stream
* multipartStream.readBodyData(output);
* nextPart = multipartStream.readBoundary();
* }
* } catch(MultipartStream.MalformedStreamException e) {
* // the stream failed to follow required syntax
* } catch(IOException e) {
* // a read or write error occurred
* }
*
*
* @version $Id: MultipartStream.java 1565249 2014-02-06 13:45:33Z ggregory $
*/
public class MultipartStream {
/**
* Internal class, which is used to invoke the
* {@link ProgressListener}.
*/
public static class ProgressNotifier {
/**
* The listener to invoke.
*/
private final ProgressListener listener;
/**
* Number of expected bytes, if known, or -1.
*/
private final long contentLength;
/**
* Number of bytes, which have been read so far.
*/
private long bytesRead;
/**
* Number of items, which have been read so far.
*/
private int items;
/**
* Creates a new instance with the given listener
* and content length.
*
* @param pListener The listener to invoke.
* @param pContentLength The expected content length.
*/
ProgressNotifier(ProgressListener pListener, long pContentLength) {
listener = pListener;
contentLength = pContentLength;
}
/**
* Called to indicate that bytes have been read.
*
* @param pBytes Number of bytes, which have been read.
*/
void noteBytesRead(int pBytes) {
/* Indicates, that the given number of bytes have been read from
* the input stream.
*/
bytesRead += pBytes;
notifyListener();
}
/**
* Called to indicate, that a new file item has been detected.
*/
void noteItem() {
++items;
notifyListener();
}
/**
* Called for notifying the listener.
*/
private void notifyListener() {
if (listener != null) {
listener.update(bytesRead, contentLength, items);
}
}
}
// ----------------------------------------------------- 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 header-part 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 header-part
* (CRLFCRLF).
*/
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 (CRLF).
*/
protected static final byte[] FIELD_SEPARATOR = {CR, LF};
/**
* A byte sequence that that follows a delimiter of the last
* encapsulation in the stream (--).
*/
protected static final byte[] STREAM_TERMINATOR = {DASH, DASH};
/**
* A byte sequence that precedes a boundary (CRLF--).
*/
protected static final byte[] BOUNDARY_PREFIX = {CR, LF, DASH, DASH};
// ----------------------------------------------------------- Data members
/**
* The input stream from which data is read.
*/
private final InputStream input;
/**
* The length of the boundary token plus the leading CRLF--.
*/
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 final int bufSize;
/**
* The buffer used for processing the request.
*/
private final byte[] buffer;
/**
* The index of first valid character in the buffer.
*
* 0 <= head < bufSize
*/
private int head;
/**
* The index of last valid character in the buffer + 1.
*
* 0 <= tail <= bufSize
*/
private int tail;
/**
* The content encoding to use when reading headers.
*/
private String headerEncoding;
/**
* The progress notifier, if any, or null.
*/
private final ProgressNotifier notifier;
// ----------------------------------------------------------- Constructors
/**
* Creates a new instance.
*
* @deprecated 1.2.1 Use {@link #MultipartStream(InputStream, byte[], int,
* ProgressNotifier)}
*/
@Deprecated
public MultipartStream() {
this(null, null, null);
}
/**
* MultipartStream with a custom size buffer
* and no progress notifier.
*
* InputStream to serve as a data source.
* @param boundary The token used for dividing the stream into
* encapsulations.
* @param bufSize The size of the buffer to be used, in bytes.
*
* @deprecated 1.2.1 Use {@link #MultipartStream(InputStream, byte[], int,
* ProgressNotifier)}.
*/
@Deprecated
public MultipartStream(InputStream input, byte[] boundary, int bufSize) {
this(input, boundary, bufSize, null);
}
/**
* MultipartStream with a custom size buffer.
*
* InputStream to serve as a data source.
* @param boundary The token used for dividing the stream into
* encapsulations.
* @param bufSize The size of the buffer to be used, in bytes.
* @param pNotifier The notifier, which is used for calling the
* progress listener, if any.
*
* @throws IllegalArgumentException If the buffer size is too small
*
* @since 1.3.1
*/
public MultipartStream(InputStream input,
byte[] boundary,
int bufSize,
ProgressNotifier pNotifier) {
if (boundary == null) {
throw new IllegalArgumentException("boundary may not be null");
}
this.input = input;
this.bufSize = bufSize;
this.buffer = new byte[bufSize];
this.notifier = pNotifier;
// We prepend CR/LF to the boundary to chop trailing CR/LF from
// body-data tokens.
this.boundaryLength = boundary.length + BOUNDARY_PREFIX.length;
if (bufSize < this.boundaryLength + 1) {
throw new IllegalArgumentException(
"The buffer size specified for the MultipartStream is too small");
}
this.boundary = new byte[this.boundaryLength];
this.keepRegion = this.boundary.length;
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;
}
/**
* MultipartStream with a default size buffer.
*
* @param input The InputStream to serve as a data source.
* @param boundary The token used for dividing the stream into
* encapsulations.
* @param pNotifier An object for calling the progress listener, if any.
*
*
* @see #MultipartStream(InputStream, byte[], int, ProgressNotifier)
*/
MultipartStream(InputStream input,
byte[] boundary,
ProgressNotifier pNotifier) {
this(input, boundary, DEFAULT_BUFSIZE, pNotifier);
}
/**
* MultipartStream with a default size buffer.
*
* @param input The InputStream to serve as a data source.
* @param boundary The token used for dividing the stream into
* encapsulations.
*
* @deprecated 1.2.1 Use {@link #MultipartStream(InputStream, byte[], int,
* ProgressNotifier)}.
*/
@Deprecated
public MultipartStream(InputStream input,
byte[] boundary) {
this(input, boundary, DEFAULT_BUFSIZE, null);
}
// --------------------------------------------------------- Public methods
/**
* 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 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 null, 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 buffer, 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");
}
if (notifier != null) {
notifier.noteBytesRead(tail);
}
}
return buffer[head++];
}
/**
* Skips a boundary token, and checks whether more
* encapsulations are contained in the stream.
*
* @return true if there are more encapsulations in
* this stream; false otherwise.
*
* @throws FileUploadIOException if the bytes read from the stream exceeded the size limits
* @throws MalformedStreamException if the stream ends unexpectedly or
* fails to follow required syntax.
*/
public boolean readBoundary()
throws FileUploadIOException, 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 (FileUploadIOException e) {
// wraps a SizeException, re-throw as it will be unwrapped later
throw e;
} catch (IOException e) {
throw new MalformedStreamException("Stream ended unexpectedly");
}
return nextChunk;
}
/**
* required
* to be of the same length as the boundary token in parent stream.
*
* boundary
* 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);
}
/**
* header-part of the current
* encapsulation.
*
* CRLF marker. Parsing is left to the
* application.
*
* header-part of the current encapsulation.
*
* @throws FileUploadIOException if the bytes read from the stream exceeded the size limits.
* @throws MalformedStreamException if the stream ends unexpectedly.
*/
public String readHeaders() throws FileUploadIOException, MalformedStreamException {
int i = 0;
byte b;
// to support multi-byte characters
ByteArrayOutputStream baos = new ByteArrayOutputStream();
int size = 0;
while (i < HEADER_SEPARATOR.length) {
try {
b = readByte();
} catch (FileUploadIOException e) {
// wraps a SizeException, re-throw as it will be unwrapped later
throw e;
} catch (IOException e) {
throw new MalformedStreamException("Stream ended unexpectedly");
}
if (++size > HEADER_PART_SIZE_MAX) {
throw new MalformedStreamException(
format("Header section has more than %s bytes (maybe it is not properly terminated)",
Integer.valueOf(HEADER_PART_SIZE_MAX)));
}
if (b == HEADER_SEPARATOR[i]) {
i++;
} else {
i = 0;
}
baos.write(b);
}
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;
}
/**
* body-data from the current
* encapsulation and writes its contents into the
* output Stream.
*
* Stream to write data into. May
* be null, in which case this method is equivalent
* to {@link #discardBodyData()}.
*
* @return the amount of data written.
*
* @throws MalformedStreamException if the stream ends unexpectedly.
* @throws IOException if an i/o error occurs.
*/
public int readBodyData(OutputStream output)
throws MalformedStreamException, IOException {
final InputStream istream = newInputStream();
return (int) Streams.copy(istream, output, false);
}
/**
* Creates a new {@link ItemInputStream}.
* @return A new instance of {@link ItemInputStream}.
*/
ItemInputStream newInputStream() {
return new ItemInputStream();
}
/**
* body-data from the current
* encapsulation and discards it.
*
* encapsulation.
*
* @return true if an encapsulation was found in
* the stream.
*
* @throws IOException 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 succeeded, 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;
}
}
/**
* Compares count first bytes in the arrays
* a and b.
*
* @param a The first array to compare.
* @param b The second array to compare.
* @param count How many bytes should be compared.
*
* @return 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;
}
/**
* Searches for a byte of specified value in the buffer,
* starting at the specified position.
*
* @param value The value to find.
* @param pos The starting position for searching.
*
* @return 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;
}
/**
* Searches for the boundary in the buffer
* region delimited by head and tail.
*
* @return 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;
}
/**
* Thrown to indicate that the input stream fails to follow the
* required syntax.
*/
public static class MalformedStreamException extends IOException {
/**
* The UID to use when serializing this instance.
*/
private static final long serialVersionUID = 6466926458059796677L;
/**
* Constructs a MalformedStreamException with no
* detail message.
*/
public MalformedStreamException() {
super();
}
/**
* Constructs an MalformedStreamException with
* the specified detail message.
*
* @param message The detail message.
*/
public MalformedStreamException(String message) {
super(message);
}
}
/**
* Thrown upon attempt of setting an invalid boundary token.
*/
public static class IllegalBoundaryException extends IOException {
/**
* The UID to use when serializing this instance.
*/
private static final long serialVersionUID = -161533165102632918L;
/**
* Constructs an IllegalBoundaryException with no
* detail message.
*/
public IllegalBoundaryException() {
super();
}
/**
* Constructs an IllegalBoundaryException with
* the specified detail message.
*
* @param message The detail message.
*/
public IllegalBoundaryException(String message) {
super(message);
}
}
/**
* An {@link InputStream} for reading an items contents.
*/
public class ItemInputStream extends InputStream implements Closeable {
/**
* The number of bytes, which have been read so far.
*/
private long total;
/**
* The number of bytes, which must be hold, because
* they might be a part of the boundary.
*/
private int pad;
/**
* The current offset in the buffer.
*/
private int pos;
/**
* Whether the stream is already closed.
*/
private boolean closed;
/**
* Creates a new instance.
*/
ItemInputStream() {
findSeparator();
}
/**
* Called for finding the separator.
*/
private void findSeparator() {
pos = MultipartStream.this.findSeparator();
if (pos == -1) {
if (tail - head > keepRegion) {
pad = keepRegion;
} else {
pad = tail - head;
}
}
}
/**
* Returns the number of bytes, which have been read
* by the stream.
*
* @return Number of bytes, which have been read so far.
*/
public long getBytesRead() {
return total;
}
/**
* Returns the number of bytes, which are currently
* available, without blocking.
*
* @throws IOException An I/O error occurs.
* @return Number of bytes in the buffer.
*/
@Override
public int available() throws IOException {
if (pos == -1) {
return tail - head - pad;
}
return pos - head;
}
/**
* Offset when converting negative bytes to integers.
*/
private static final int BYTE_POSITIVE_OFFSET = 256;
/**
* Returns the next byte in the stream.
*
* @return The next byte in the stream, as a non-negative
* integer, or -1 for EOF.
* @throws IOException An I/O error occurred.
*/
@Override
public int read() throws IOException {
if (closed) {
throw new FileItemStream.ItemSkippedException();
}
if (available() == 0 && makeAvailable() == 0) {
return -1;
}
++total;
int b = buffer[head++];
if (b >= 0) {
return b;
}
return b + BYTE_POSITIVE_OFFSET;
}
/**
* Reads bytes into the given buffer.
*
* @param b The destination buffer, where to write to.
* @param off Offset of the first byte in the buffer.
* @param len Maximum number of bytes to read.
* @return Number of bytes, which have been actually read,
* or -1 for EOF.
* @throws IOException An I/O error occurred.
*/
@Override
public int read(byte[] b, int off, int len) throws IOException {
if (closed) {
throw new FileItemStream.ItemSkippedException();
}
if (len == 0) {
return 0;
}
int res = available();
if (res == 0) {
res = makeAvailable();
if (res == 0) {
return -1;
}
}
res = Math.min(res, len);
System.arraycopy(buffer, head, b, off, res);
head += res;
total += res;
return res;
}
/**
* Closes the input stream.
*
* @throws IOException An I/O error occurred.
*/
@Override
public void close() throws IOException {
close(false);
}
/**
* Closes the input stream.
*
* @param pCloseUnderlying Whether to close the underlying stream
* (hard close)
* @throws IOException An I/O error occurred.
*/
public void close(boolean pCloseUnderlying) throws IOException {
if (closed) {
return;
}
if (pCloseUnderlying) {
closed = true;
input.close();
} else {
for (;;) {
int av = available();
if (av == 0) {
av = makeAvailable();
if (av == 0) {
break;
}
}
skip(av);
}
}
closed = true;
}
/**
* Skips the given number of bytes.
*
* @param bytes Number of bytes to skip.
* @return The number of bytes, which have actually been
* skipped.
* @throws IOException An I/O error occurred.
*/
@Override
public long skip(long bytes) throws IOException {
if (closed) {
throw new FileItemStream.ItemSkippedException();
}
int av = available();
if (av == 0) {
av = makeAvailable();
if (av == 0) {
return 0;
}
}
long res = Math.min(av, bytes);
head += res;
return res;
}
/**
* Attempts to read more data.
*
* @return Number of available bytes
* @throws IOException An I/O error occurred.
*/
private int makeAvailable() throws IOException {
if (pos != -1) {
return 0;
}
// Move the data to the beginning of the buffer.
total += tail - head - pad;
System.arraycopy(buffer, tail - pad, buffer, 0, pad);
// Refill buffer with new data.
head = 0;
tail = pad;
for (;;) {
int bytesRead = input.read(buffer, tail, bufSize - tail);
if (bytesRead == -1) {
// The last pad amount is left in the buffer.
// Boundary can't be in there so signal an error
// condition.
final String msg = "Stream ended unexpectedly";
throw new MalformedStreamException(msg);
}
if (notifier != null) {
notifier.noteBytesRead(bytesRead);
}
tail += bytesRead;
findSeparator();
int av = available();
if (av > 0 || pos != -1) {
return av;
}
}
}
/**
* Returns, whether the stream is closed.
*
* @return True, if the stream is closed, otherwise false.
*/
public boolean isClosed() {
return closed;
}
}
}
commons-fileupload-1.3.1-src/src/main/java/org/apache/commons/fileupload/package-info.java 100644 0 0 7471 12274737401 26677 0 ustar 0 0 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*/
/**
* public void doPost(HttpServletRequest req, HttpServletResponse res) {
* DiskFileItemFactory factory = new DiskFileItemFactory();
* // maximum size that will be stored in memory
* factory.setSizeThreshold(4096);
* // the location for saving data that is larger than getSizeThreshold()
* factory.setRepository(new File("/tmp"));
*
* ServletFileUpload upload = new ServletFileUpload(factory);
* // maximum size before a FileUploadException will be thrown
* upload.setSizeMax(1000000);
*
* List fileItems = upload.parseRequest(req);
* // assume we know there are two files. The first file is a small
* // text file, the second is unknown and is written to a file on
* // the server
* Iterator i = fileItems.iterator();
* String comment = ((FileItem)i.next()).getString();
* FileItem fi = (FileItem)i.next();
* // filename on the client
* String fileName = fi.getName();
* // save comment and filename to database
* ...
* // write the file
* fi.write(new File("/www/uploads/", fileName));
* }
*
* String. Before calling the getString method,
* the data may have been in memory or on disk depending on its size. The
* second file we assume it will be large and therefore never explicitly
* load it into memory, though if it is less than 4096 bytes it will be
* in memory before it is written to its final location. When writing to
* the final location, if the data is larger than the threshold, an attempt
* is made to rename the temporary file to the given location. If it cannot
* be renamed, it is streamed to the new location.
* param1 = value; param2 = "anything goes; really"; param3
* ActionRequest instance,
* and a suitable
* {@link org.apache.commons.fileupload.FileItemFactory FileItemFactory}
* implementation, such as
* {@link org.apache.commons.fileupload.disk.DiskFileItemFactory DiskFileItemFactory}.
*
* DiskFileItemFactory factory = new DiskFileItemFactory();
* // Configure the factory here, if desired.
* PortletFileUpload upload = new PortletFileUpload(factory);
* // Configure the uploader here, if desired.
* List fileItems = upload.parseRequest(request);
*
* multipart/mixed encoding type, as specified by
* RFC 1867. Use
* {@link org.apache.commons.fileupload.servlet.ServletFileUpload
* #parseRequest(javax.servlet.http.HttpServletRequest)} to acquire a list
* of {@link org.apache.commons.fileupload.FileItem FileItems} associated
* with a given HTML widget.true if the request is multipart;
* false otherwise.
*/
public static final boolean isMultipartContent(ActionRequest request) {
return FileUploadBase.isMultipartContent(
new PortletRequestContext(request));
}
// ----------------------------------------------------------- Constructors
/**
* Constructs an uninitialised instance of this class. A factory must be
* configured, using setFileItemFactory(), before attempting
* to parse requests.
*
* @see FileUpload#FileUpload(FileItemFactory)
*/
public PortletFileUpload() {
super();
}
/**
* Constructs an instance of this class which uses the supplied factory to
* create FileItem instances.
*
* @see FileUpload#FileUpload()
* @param fileItemFactory The factory to use for creating file items.
*/
public PortletFileUpload(FileItemFactory fileItemFactory) {
super(fileItemFactory);
}
// --------------------------------------------------------- Public methods
/**
* Processes an RFC 1867
* compliant multipart/form-data stream.
*
* @param request The portlet request to be parsed.
*
* @return A list of FileItem instances parsed from the
* request, in the order that they were transmitted.
*
* @throws FileUploadException if there are problems reading/parsing
* the request or storing files.
*/
public Listmultipart/form-data stream.
*
* @param request The portlet request to be parsed.
*
* @return A map of FileItem instances parsed from the request.
*
* @throws FileUploadException if there are problems reading/parsing
* the request or storing files.
*
* @since 1.3
*/
public Mapmultipart/form-data stream.
*
* @param request The portlet request to be parsed.
*
* @return An iterator to instances of FileItemStream
* parsed from the request, in the order that they were
* transmitted.
*
* @throws FileUploadException if there are problems reading/parsing
* the request or storing files.
* @throws IOException An I/O error occurred. This may be a network
* error while communicating with the client or a problem while
* storing the uploaded content.
*/
public FileItemIterator getItemIterator(ActionRequest request)
throws FileUploadException, IOException {
return super.getItemIterator(new PortletRequestContext(request));
}
}
././@LongLink 100644 0 0 154 12274740161 10257 L ustar 0 0 commons-fileupload-1.3.1-src/src/main/java/org/apache/commons/fileupload/portlet/PortletRequestContext.java commons-fileupload-1.3.1-src/src/main/java/org/apache/commons/fileupload/portlet/PortletRequestConte100644 0 0 7451 12274737402 31116 0 ustar 0 0 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.portlet;
import static java.lang.String.format;
import java.io.IOException;
import java.io.InputStream;
import javax.portlet.ActionRequest;
import org.apache.commons.fileupload.FileUploadBase;
import org.apache.commons.fileupload.UploadContext;
/**
* HttpServletRequest
* instance, and a suitable
* {@link org.apache.commons.fileupload.FileItemFactory FileItemFactory}
* implementation, such as
* {@link org.apache.commons.fileupload.disk.DiskFileItemFactory DiskFileItemFactory}.
*
* DiskFileItemFactory factory = new DiskFileItemFactory();
* // Configure the factory here, if desired.
* ServletFileUpload upload = new ServletFileUpload(factory);
* // Configure the uploader here, if desired.
* List fileItems = upload.parseRequest(request);
*
* multipart/mixed encoding type, as specified by
* RFC 1867. Use {@link
* #parseRequest(HttpServletRequest)} to acquire a list of {@link
* org.apache.commons.fileupload.FileItem}s associated with a given HTML
* widget.true if the request is multipart;
* false otherwise.
*/
public static final boolean isMultipartContent(
HttpServletRequest request) {
if (!POST_METHOD.equalsIgnoreCase(request.getMethod())) {
return false;
}
return FileUploadBase.isMultipartContent(new ServletRequestContext(request));
}
// ----------------------------------------------------------- Constructors
/**
* Constructs an uninitialised instance of this class. A factory must be
* configured, using setFileItemFactory(), before attempting
* to parse requests.
*
* @see FileUpload#FileUpload(FileItemFactory)
*/
public ServletFileUpload() {
super();
}
/**
* Constructs an instance of this class which uses the supplied factory to
* create FileItem instances.
*
* @see FileUpload#FileUpload()
* @param fileItemFactory The factory to use for creating file items.
*/
public ServletFileUpload(FileItemFactory fileItemFactory) {
super(fileItemFactory);
}
// --------------------------------------------------------- Public methods
/**
* Processes an RFC 1867
* compliant multipart/form-data stream.
*
* @param request The servlet request to be parsed.
*
* @return A list of FileItem instances parsed from the
* request, in the order that they were transmitted.
*
* @throws FileUploadException if there are problems reading/parsing
* the request or storing files.
*/
@Override
public Listmultipart/form-data stream.
*
* @param request The servlet request to be parsed.
*
* @return A map of FileItem instances parsed from the request.
*
* @throws FileUploadException if there are problems reading/parsing
* the request or storing files.
*
* @since 1.3
*/
public Mapmultipart/form-data stream.
*
* @param request The servlet request to be parsed.
*
* @return An iterator to instances of FileItemStream
* parsed from the request, in the order that they were
* transmitted.
*
* @throws FileUploadException if there are problems reading/parsing
* the request or storing files.
* @throws IOException An I/O error occurred. This may be a network
* error while communicating with the client or a problem while
* storing the uploaded content.
*/
public FileItemIterator getItemIterator(HttpServletRequest request)
throws FileUploadException, IOException {
return super.getItemIterator(new ServletRequestContext(request));
}
}
././@LongLink 100644 0 0 154 12274740161 10257 L ustar 0 0 commons-fileupload-1.3.1-src/src/main/java/org/apache/commons/fileupload/servlet/ServletRequestContext.java commons-fileupload-1.3.1-src/src/main/java/org/apache/commons/fileupload/servlet/ServletRequestConte100644 0 0 7452 12274737401 31104 0 ustar 0 0 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.servlet;
import static java.lang.String.format;
import java.io.IOException;
import java.io.InputStream;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.fileupload.FileUploadBase;
import org.apache.commons.fileupload.UploadContext;
/**
* String keys to a List of
* String instances.
*/
private final Mapint in the range
* 0 to 255. If no byte is available
* because the end of the stream has been reached, the value
* -1 is returned. This method blocks until input data
* is available, the end of the stream is detected, or an exception
* is thrown.
* in.read() and returns the result.
*
* @return the next byte of data, or -1 if the end of the
* stream is reached.
* @exception IOException if an I/O error occurs.
* @see java.io.FilterInputStream#in
*/
@Override
public int read() throws IOException {
int res = super.read();
if (res != -1) {
count++;
checkLimit();
}
return res;
}
/**
* Reads up to len bytes of data from this input stream
* into an array of bytes. If len is not zero, the method
* blocks until some input is available; otherwise, no
* bytes are read and 0 is returned.
* in.read(b, off, len)
* and returns the result.
*
* @param b the buffer into which the data is read.
* @param off The start offset in the destination array
* b.
* @param len the maximum number of bytes read.
* @return the total number of bytes read into the buffer, or
* -1 if there is no more data because the end of
* the stream has been reached.
* @exception NullPointerException If b is null.
* @exception IndexOutOfBoundsException If off is negative,
* len is negative, or len is greater than
* b.length - off
* @exception IOException if an I/O error occurs.
* @see java.io.FilterInputStream#in
*/
@Override
public int read(byte[] b, int off, int len) throws IOException {
int res = super.read(b, off, len);
if (res > 0) {
count += res;
checkLimit();
}
return res;
}
/**
* Returns, whether this stream is already closed.
*
* @return True, if the stream is closed, otherwise false.
* @throws IOException An I/O error occurred.
*/
public boolean isClosed() throws IOException {
return closed;
}
/**
* Closes this input stream and releases any system resources
* associated with the stream.
* This
* method simply performs in.close().
*
* @exception IOException if an I/O error occurs.
* @see java.io.FilterInputStream#in
*/
@Override
public void close() throws IOException {
closed = true;
super.close();
}
}
././@LongLink 100644 0 0 146 12274740161 10260 L ustar 0 0 commons-fileupload-1.3.1-src/src/main/java/org/apache/commons/fileupload/util/mime/Base64Decoder.java commons-fileupload-1.3.1-src/src/main/java/org/apache/commons/fileupload/util/mime/Base64Decoder.jav100644 0 0 14177 12274737401 30451 0 ustar 0 0 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.util.mime;
import java.io.IOException;
import java.io.OutputStream;
/**
* @since 1.3
*/
final class Base64Decoder {
/**
* Decoding table value for invalid bytes.
*/
private static final int INVALID_BYTE = -1; // must be outside range 0-63
/**
* Decoding table value for padding bytes, so can detect PAD afer conversion.
*/
private static final int PAD_BYTE = -2; // must be outside range 0-63
/**
* Mask to treat byte as unsigned integer.
*/
private static final int MASK_BYTE_UNSIGNED = 0xFF;
/**
* Number of bytes per encoded chunk - 4 6bit bytes produce 3 8bit bytes on output.
*/
private static final int INPUT_BYTES_PER_CHUNK = 4;
/**
* Set up the encoding table.
*/
private static final byte[] ENCODING_TABLE = {
(byte) 'A', (byte) 'B', (byte) 'C', (byte) 'D', (byte) 'E', (byte) 'F', (byte) 'G',
(byte) 'H', (byte) 'I', (byte) 'J', (byte) 'K', (byte) 'L', (byte) 'M', (byte) 'N',
(byte) 'O', (byte) 'P', (byte) 'Q', (byte) 'R', (byte) 'S', (byte) 'T', (byte) 'U',
(byte) 'V', (byte) 'W', (byte) 'X', (byte) 'Y', (byte) 'Z',
(byte) 'a', (byte) 'b', (byte) 'c', (byte) 'd', (byte) 'e', (byte) 'f', (byte) 'g',
(byte) 'h', (byte) 'i', (byte) 'j', (byte) 'k', (byte) 'l', (byte) 'm', (byte) 'n',
(byte) 'o', (byte) 'p', (byte) 'q', (byte) 'r', (byte) 's', (byte) 't', (byte) 'u',
(byte) 'v', (byte) 'w', (byte) 'x', (byte) 'y', (byte) 'z',
(byte) '0', (byte) '1', (byte) '2', (byte) '3', (byte) '4', (byte) '5', (byte) '6',
(byte) '7', (byte) '8', (byte) '9',
(byte) '+', (byte) '/'
};
/**
* The padding byte.
*/
private static final byte PADDING = (byte) '=';
/**
* Set up the decoding table; this is indexed by a byte converted to an unsigned int,
* so must be at least as large as the number of different byte values,
* positive and negative and zero.
*/
private static final byte[] DECODING_TABLE = new byte[Byte.MAX_VALUE - Byte.MIN_VALUE + 1];
static {
// Initialise as all invalid characters
for (int i = 0; i < DECODING_TABLE.length; i++) {
DECODING_TABLE[i] = INVALID_BYTE;
}
// set up valid characters
for (int i = 0; i < ENCODING_TABLE.length; i++) {
DECODING_TABLE[ENCODING_TABLE[i]] = (byte) i;
}
// Allow pad byte to be easily detected after conversion
DECODING_TABLE[PADDING] = PAD_BYTE;
}
/**
* Hidden constructor, this class must not be instantiated.
*/
private Base64Decoder() {
// do nothing
}
/**
* Decode the base 64 encoded byte data writing it to the given output stream,
* whitespace characters will be ignored.
*
* @param data the buffer containing the Base64-encoded data
* @param out the output stream to hold the decoded bytes
*
* @return the number of bytes produced.
* @throws IOException thrown when the padding is incorrect or the input is truncated.
*/
public static int decode(byte[] data, OutputStream out) throws IOException {
int outLen = 0;
byte [] cache = new byte[INPUT_BYTES_PER_CHUNK];
int cachedBytes = 0;
for (byte b : data) {
final byte d = DECODING_TABLE[MASK_BYTE_UNSIGNED & b];
if (d == INVALID_BYTE) {
continue; // Ignore invalid bytes
}
cache[cachedBytes++] = d;
if (cachedBytes == INPUT_BYTES_PER_CHUNK) {
// CHECKSTYLE IGNORE MagicNumber FOR NEXT 4 LINES
final byte b1 = cache[0];
final byte b2 = cache[1];
final byte b3 = cache[2];
final byte b4 = cache[3];
if (b1 == PAD_BYTE || b2 == PAD_BYTE) {
throw new IOException("Invalid Base64 input: incorrect padding, first two bytes cannot be padding");
}
// Convert 4 6-bit bytes to 3 8-bit bytes
// CHECKSTYLE IGNORE MagicNumber FOR NEXT 1 LINE
out.write((b1 << 2) | (b2 >> 4)); // 6 bits of b1 plus 2 bits of b2
outLen++;
if (b3 != PAD_BYTE) {
// CHECKSTYLE IGNORE MagicNumber FOR NEXT 1 LINE
out.write((b2 << 4) | (b3 >> 2)); // 4 bits of b2 plus 4 bits of b3
outLen++;
if (b4 != PAD_BYTE) {
// CHECKSTYLE IGNORE MagicNumber FOR NEXT 1 LINE
out.write((b3 << 6) | b4); // 2 bits of b3 plus 6 bits of b4
outLen++;
}
} else if (b4 != PAD_BYTE) { // if byte 3 is pad, byte 4 must be pad too
throw new // line wrap to avoid 120 char limit
IOException("Invalid Base64 input: incorrect padding, 4th byte must be padding if 3rd byte is");
}
cachedBytes = 0;
}
}
// Check for anything left over
if (cachedBytes != 0) {
throw new IOException("Invalid Base64 input: truncated");
}
return outLen;
}
}
commons-fileupload-1.3.1-src/src/main/java/org/apache/commons/fileupload/util/mime/MimeUtility.java 100644 0 0 25606 12274737401 30552 0 ustar 0 0 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.util.mime;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
/**
* Utility class to decode MIME texts.
*
* @since 1.3
*/
public final class MimeUtility {
/**
* The {@code US-ASCII} charset identifier constant.
*/
private static final String US_ASCII_CHARSET = "US-ASCII";
/**
* The marker to indicate text is encoded with BASE64 algorithm.
*/
private static final String BASE64_ENCODING_MARKER = "B";
/**
* The marker to indicate text is encoded with QuotedPrintable algorithm.
*/
private static final String QUOTEDPRINTABLE_ENCODING_MARKER = "Q";
/**
* If the text contains any encoded tokens, those tokens will be marked with "=?".
*/
private static final String ENCODED_TOKEN_MARKER = "=?";
/**
* If the text contains any encoded tokens, those tokens will terminate with "=?".
*/
private static final String ENCODED_TOKEN_FINISHER = "?=";
/**
* The linear whitespace chars sequence.
*/
private static final String LINEAR_WHITESPACE = " \t\r\n";
/**
* Mappings between MIME and Java charset.
*/
private static final Map
* copy(pInputStream, pOutputStream, new byte[8192]);
*
*
* @param inputStream The input stream, which is being read.
* It is guaranteed, that {@link InputStream#close()} is called
* on the stream.
* @param outputStream The output stream, to which data should
* be written. May be null, in which case the input streams
* contents are simply discarded.
* @param closeOutputStream True guarantees, that {@link OutputStream#close()}
* is called on the stream. False indicates, that only
* {@link OutputStream#flush()} should be called finally.
*
* @return Number of bytes, which have been copied.
* @throws IOException An I/O error occurred.
*/
public static long copy(InputStream inputStream, OutputStream outputStream, boolean closeOutputStream)
throws IOException {
return copy(inputStream, outputStream, closeOutputStream, new byte[DEFAULT_BUFFER_SIZE]);
}
/**
* Copies the contents of the given {@link InputStream}
* to the given {@link OutputStream}.
*
* @param inputStream The input stream, which is being read.
* It is guaranteed, that {@link InputStream#close()} is called
* on the stream.
* @param outputStream The output stream, to which data should
* be written. May be null, in which case the input streams
* contents are simply discarded.
* @param closeOutputStream True guarantees, that {@link OutputStream#close()}
* is called on the stream. False indicates, that only
* {@link OutputStream#flush()} should be called finally.
* @param buffer Temporary buffer, which is to be used for
* copying data.
* @return Number of bytes, which have been copied.
* @throws IOException An I/O error occurred.
*/
public static long copy(InputStream inputStream,
OutputStream outputStream, boolean closeOutputStream,
byte[] buffer)
throws IOException {
OutputStream out = outputStream;
InputStream in = inputStream;
try {
long total = 0;
for (;;) {
int res = in.read(buffer);
if (res == -1) {
break;
}
if (res > 0) {
total += res;
if (out != null) {
out.write(buffer, 0, res);
}
}
}
if (out != null) {
if (closeOutputStream) {
out.close();
} else {
out.flush();
}
out = null;
}
in.close();
in = null;
return total;
} finally {
IOUtils.closeQuietly(in);
if (closeOutputStream) {
IOUtils.closeQuietly(out);
}
}
}
/**
* This convenience method allows to read a
* {@link org.apache.commons.fileupload.FileItemStream}'s
* content into a string. The platform's default character encoding
* is used for converting bytes into characters.
*
* @param inputStream The input stream to read.
* @see #asString(InputStream, String)
* @return The streams contents, as a string.
* @throws IOException An I/O error occurred.
*/
public static String asString(InputStream inputStream) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
copy(inputStream, baos, true);
return baos.toString();
}
/**
* This convenience method allows to read a
* {@link org.apache.commons.fileupload.FileItemStream}'s
* content into a string, using the given character encoding.
*
* @param inputStream The input stream to read.
* @param encoding The character encoding, typically "UTF-8".
* @see #asString(InputStream)
* @return The streams contents, as a string.
* @throws IOException An I/O error occurred.
*/
public static String asString(InputStream inputStream, String encoding) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
copy(inputStream, baos, true);
return baos.toString(encoding);
}
/**
* Checks, whether the given file name is valid in the sense,
* that it doesn't contain any NUL characters. If the file name
* is valid, it will be returned without any modifications. Otherwise,
* an {@link InvalidFileNameException} is raised.
*
* @param fileName The file name to check
* @return Unmodified file name, if valid.
* @throws InvalidFileNameException The file name was found to be invalid.
*/
public static String checkFileName(String fileName) {
if (fileName != null && fileName.indexOf('\u0000') != -1) {
// pFileName.replace("\u0000", "\\0")
final StringBuilder sb = new StringBuilder();
for (int i = 0; i < fileName.length(); i++) {
char c = fileName.charAt(i);
switch (c) {
case 0:
sb.append("\\0");
break;
default:
sb.append(c);
break;
}
}
throw new InvalidFileNameException(fileName,
"Invalid file name: " + sb);
}
return fileName;
}
}
commons-fileupload-1.3.1-src/src/media/logo.xcf 100644 0 0 61533 12274737400 16573 0 ustar 0 0 gimp xcf file , d B B /
gimp-comment Created with The GIMP 7 4 C a ,
Text Layer#2
S 0 W , s + , f
UU 8 U ! q 8 U 8 U 8 8 q U8 8Uq U8 8 88 8U U UU 8
U8
q
8 8q UUU U UU
q
U 8U
U
U qUU
U
U U
U U
U
U
U
U U q
U
U qq U
U U U
U q q ƪ q qq UqƍU UU 8qq8 88 U U U 8UU8 U8 ? U U U U8 8 8 UU 88
8 U U U U U U UU8
U UU U U 8U U U U q 8 U U U Uq U U U U U U U U U U U U U U U U q U
8 U U
8 U q U U q q q qq 8 q U U ƪ
U q 8 U U 8UU8 U 8UU8 UU$ U 9 U 9 U 9 U 9 U 9 U 9 U 8 6 UqU8 2
q 8 ; U ; U ; U ; U ; U ; U ; U ; U ; U ; U ; U U UU8 UU qq
8U UU qU UU 8 q U U q U U q U 8 U q 88 U q U
8 8 U q Uƪ q U U U q U
8 U
qq 8 U
8 U U q U U q q U U UU 8 8 88 U U q 8 U q Uq U 8 U U 8 U U 8 ƪ ƪ8 U 8q U ƍU q8 8 q qU
U8
8UU U UU U 8q U U U U U U U U 8U U q U U U U U U U U U U U U8 UqU8 8 UU } f 3 < Drop-Shadow#2 h
O , < 4 4 < o & 0
/
!! !
$).1332001342,$
#(+)$ '-28=BFGFDCEGHE=1$ *5=@>6*
%.5;?DJPUWWVUVYYUJ<, +:HSWTI9( &2=CFHKOV\`aa`acc]RB1"$4FXflhZG1 $3AKOOLKNSZ_aab\QA0!'9Ndt|xhQ9# /APYZUMGFIOTWWXWRG9* &9Qi|qY>'
':N^ecYLA;BEE .D^y}eO=/'#$)3@LTUOC3#+D`zzaE, $,27;?DJQVY ,B\w{bK9-%#'/=N]hjcS?++D`zzaE- (2:?ACEJQZci (=Wsu\E3'! &2CWjwzr`I2 ,DazzaF/! *6AHJIHGKR]jt #7QmoU=* #0D[q}iP7",DazzaG1%#*7EPUUPKGIP\ky 2LhiN5# ,AZrnT9$,DazzbH4)*5DT^a]UMGGMYiy .Hd}}eI0 (=WqqV;%,DazzcI6.2?QakleZOHFKVdt ,Fb{{bF- $9SnqW<%,Daz{cK939I\lusj]PHEHP\i +DazzaE+
!6PkqW<&,Daz{dL<7?Qeu|xl]ND@AGOY *D`zz`D* 4OjqW<&,Daz{dM>;DWl{ykYJ>87:@F *D`zz`D* 3NiqW<&,Daz{eN?=H[pyhTB5-*+.2 *D`zz`D* 3MiqW<&,Daz{eN@>J]szgQ<-$ ! *D`zz`D* 3MiqW<&,Daz{eN@>J^t|hQ:) +DazzaD+ 3NiqW<&,Daz{eN?>I^tmU>* +DazzaD+ 3NiqW<&,Eaz{dM>;F[rv_G2# +Ea{{bE,
4OjrX=' -Eaz{dM=9BVnkU@/$
-Gc||dG. 6PksY?) /Gc||eM<6=Og}zfSB6.++ /Ie}}eJ0
#8Rlt[@+ !1Id||eM;37F\swfWKB=; 2Ke|}fL3 %:Smt\B- $4Ke{{fM:01org.apache.commons.io package.
String fileName = item.getName();
if (fileName != null) {
filename = FilenameUtils.getName(filename);
}
items = new ArrayList
[if-any logo][end]
PGP link downloads the OpenPGP compatible signature from our main site.
The MD5 link downloads the checksum from the main site.
commons-fileupload-1.3.1-bin.tar.gz
md5
pgp
commons-fileupload-1.3.1-bin.zip
md5
pgp
commons-fileupload-1.3.1-src.tar.gz
md5
pgp
commons-fileupload-1.3.1-src.zip
md5
pgp
Notes about the file:
to upload the file!
]]>
For more information on subversion and creating patches see the Apache Contributors Guide.
You may also find these links useful:
commons-fileupload-1.3.1-src/src/site/xdoc/mail-lists.xml 100644 0 0 22646 12274737402 20557 0 ustar 0 0Commons FileUpload shares mailing lists with all the other Commons Components. To make it easier for people to only read messages related to components they are interested in, the convention in Commons is to prefix the subject line of messages with the component's name, for example:
- [fileupload] Problem with the ...
Questions related to the usage of Commons FileUpload should be posted to the
User List.
The Developer List
is for questions and discussion related to the development of Commons FileUpload.
Please do not cross-post; developers are also subscribed to the user list.
Note: please don't send patches or attachments to any of the mailing lists. Patches are best handled via the Issue Tracking system. Otherwise, please upload the file to a public server and include the URL in the mail.
Please prefix the subject line of any messages for Commons FileUpload
with [fileupload] - thanks!
| Name | Subscribe | Unsubscribe | Post | Archive | Other Archives |
|---|---|---|---|---|---|
|
Commons User List
Questions on using Commons FileUpload. |
Subscribe | Unsubscribe | Post | mail-archives.apache.org | markmail.org www.mail-archive.com news.gmane.org |
|
Commons Developer List
Discussion of development of Commons FileUpload. |
Subscribe | Unsubscribe | Post | mail-archives.apache.org | markmail.org www.mail-archive.com news.gmane.org |
|
Commons Issues List
Only for e-mails automatically generated by the issue tracking system. |
Subscribe | Unsubscribe | read only | mail-archives.apache.org | markmail.org www.mail-archive.com |
|
Commons Commits List
Only for e-mails automatically generated by the source control sytem. |
Subscribe | Unsubscribe | read only | mail-archives.apache.org | markmail.org www.mail-archive.com |
Other mailing lists which you may find useful include:
| Name | Subscribe | Unsubscribe | Post | Archive | Other Archives |
|---|---|---|---|---|---|
|
Apache Announce List
General announcements of Apache project releases. |
Subscribe | Unsubscribe | read only | mail-archives.apache.org | markmail.org old.nabble.com www.mail-archive.com news.gmane.org |
Your application should detect whether or not FileUpload should be invoked, based on the HTTP method and the content type of the request.
Assuming that you have decided that FileUpload should be invoked, you
might write the following code to handle a file upload request:
The traditional API, which is described in the User Guide, assumes, that file items must be stored somewhere, before they are actually accessable by the user. This approach is convenient, because it allows easy access to an items contents. On the other hand, it is memory and time consuming.
The streaming API allows you to trade a little bit of convenience for optimal performance and and a low memory profile. Additionally, the API is more lightweight, thus easier to understand.
Again, the FileUpload class is used for accessing the
form fields and fields in the order, in which they have been sent
by the client. However, the FileItemFactory is completely
ignored.
First of all, do not forget to ensure, that a request actually is a a file upload request. This is typically done using the same static method, which you already know from the traditional API.
Now we are ready to parse the request into its constituent items. Here's how we do it:
That's all that's needed. Really!
FileUpload can be used in a number of different ways, depending upon the requirements of your application. In the simplest case, you will call a single method to parse the servlet request, and then process the list of items as they apply to your application. At the other end of the scale, you might decide to customize FileUpload to take full control of the way in which individual items are stored; for example, you might decide to stream the content into a database.
Here, we will describe the basic principles of FileUpload, and illustrate some of the simpler - and most common - usage patterns. Customization of FileUpload is described elsewhere.
FileUpload depends on Commons IO, so make sure you have the version mentioned on the dependencies page in your classpath before continuing.
A file upload request comprises an ordered list of items that
are encoded according to
RFC 1867,
"Form-based File Upload in HTML". FileUpload can parse such a request
and provide your application with a list of the individual uploaded
items. Each such item implements the FileItem interface,
regardless of its underlying implementation.
This page describes the traditional API of the commons fileupload library. The traditional API is a convenient approach. However, for ultimate performance, you might prefer the faster Streaming API.
Each file item has a number of properties that might be of interest for
your application. For example, every item has a name and a content type,
and can provide an InputStream to access its data. On the
other hand, you may need to process items differently, depending upon
whether the item is a regular form field - that is, the data came from
an ordinary text box or similar HTML field - or an uploaded file. The
FileItem interface provides the methods to make such a
determination, and to access the data in the most appropriate manner.
FileUpload creates new file items using a FileItemFactory.
This is what gives FileUpload most of its flexibility. The factory has
ultimate control over how each item is created. The factory implementation
that currently ships with FileUpload stores the item's data in memory or
on disk, depending on the size of the item (i.e. bytes of data). However,
this behavior can be customized to suit your application.
Starting with version 1.1, FileUpload supports file upload requests in both servlet and portlet environments. The usage is almost identical in the two environments, so the remainder of this document refers only to the servlet environment.
If you are building a portlet application, the following are the two distinctions you should make as you read this document:
-
Where you see references to the
ServletFileUploadclass, substitute thePortletFileUploadclass. -
Where you see references to the
HttpServletRequestclass, substitute theActionRequestclass.
Before you can work with the uploaded items, of course, you need to parse the request itself. Ensuring that the request is actually a file upload request is straightforward, but FileUpload makes it simplicity itself, by providing a static method to do just that.
Now we are ready to parse the request into its constituent items.
The simplest usage scenario is the following:
- Uploaded items should be retained in memory as long as they are reasonably small.
- Larger items should be written to a temporary file on disk.
- Very large upload requests should not be permitted.
- The built-in defaults for the maximum size of an item to be retained in memory, the maximum permitted size of an upload request, and the location of temporary files are acceptable.
Handling a request in this scenario couldn't be much simpler:
That's all that's needed. Really!
The result of the parse is a List of file items, each of
which implements the FileItem interface. Processing these
items is discussed below.
If your usage scenario is close to the simplest case, described above, but you need a little more control, you can easily customize the behavior of the upload handler or the file item factory or both. The following example shows several configuration options:
Of course, each of the configuration methods is independent of the others, but if you want to configure the factory all at once, you can do that with an alternative constructor, like this:
Should you need further control over the parsing of the request, such as storing the items elsewhere - for example, in a database - you will need to look into customizing FileUpload.
Once the parse has completed, you will have a List of file
items that you need to process. In most cases, you will want to handle
file uploads differently from regular form fields, so you might process
the list like this:
For a regular form field, you will most likely be interested only in the
name of the item, and its String value. As you might expect,
accessing these is very simple.
For a file upload, there are several different things you might want to know before you process the content. Here is an example of some of the methods you might be interested in.
With uploaded files, you generally will not want to access them via memory, unless they are small, or unless you have no other alternative. Rather, you will want to process the content as a stream, or write the entire file to its ultimate location. FileUpload provides simple means of accomplishing both of these.
Note that, in the default implementation of FileUpload, write()
will attempt to rename the file to the specified destination, if the data
is already in a temporary file. Actually copying the data is only done if
the the rename fails, for some reason, or if the data was in memory.
If you do need to access the uploaded data in memory, you need simply
call the get() method to obtain the data as an array of
bytes.
This section applies only, if you are using the DiskFileItem. In other words, it applies, if your uploaded files are written to temporary files before processing them.
Such temporary files are deleted automatically, if they are no longer
used (more precisely, if the corresponding instance of java.io.File
is garbage collected. This is done silently by the org.apache.commons.io.FileCleaner
class, which starts a reaper thread.
This reaper thread should be stopped, if it is no longer needed. In
a servlet environment, this is done by using a special servlet
context listener, called
FileCleanerCleanup.
To do so, add a section like the following to your web.xml:
The FileCleanerCleanup provides an instance of
org.apache.commons.io.FileCleaningTracker. This
instance must be used when creating a
org.apache.commons.fileupload.disk.DiskFileItemFactory.
This should be done by calling a method like the following:
To disable tracking of temporary files, you may set the
FileCleaningTracker to null. Consequently,
created files will no longer be tracked. In particular,
they will no longer be deleted automatically.
Virus scanners running on the same system as the web container can cause some unexpected behaviours for applications using FileUpload. This section describes some of the behaviours that you might encounter, and provides some ideas for how to handle them.
The default implementation of FileUpload will cause uploaded items above a certain size threshold to be written to disk. As soon as such a file is closed, any virus scanner on the system will wake up and inspect it, and potentially quarantine the file - that is, move it to a special location where it will not cause problems. This, of course, will be a surprise to the application developer, since the uploaded file item will no longer be available for processing. On the other hand, uploaded items below that same threshold will be held in memory, and therefore will not be seen by virus scanners. This allows for the possibility of a virus being retained in some form (although if it is ever written to disk, the virus scanner would locate and inspect it).
One commonly used solution is to set aside one directory on the system into which all uploaded files will be placed, and to configure the virus scanner to ignore that directory. This ensures that files will not be ripped out from under the application, but then leaves responsibility for virus scanning up to the application developer. Scanning the uploaded files for viruses can then be performed by an external process, which might move clean or cleaned files to an "approved" location, or by integrating a virus scanner within the application itself. The details of configuring an external process or integrating virus scanning into an application are outside the scope of this document.
If you expect really large file uploads, then it would be nice to report to your users, how much is already received. Even HTML pages allow to implement a progress bar by returning a multipart/replace response, or something like that.
Watching the upload progress may be done by supplying a progress listener:
Do yourself a favour and implement your first progress listener just like the above, because it shows you a pitfall: The progress listener is called quite frequently. Depending on the servlet engine and other environment factory, it may be called for any network packet! In other words, your progress listener may become a performance problem! A typical solution might be, to reduce the progress listeners activity. For example, you might emit a message only, if the number of megabytes has changed:
Hopefully this page has provided you with a good idea of how to use FileUpload in your own applications. For more detail on the methods introduced here, as well as other available methods, you should refer to the JavaDocs.
The usage described here should satisfy a large majority of file upload needs. However, should you have more complex requirements, FileUpload should still be able to help you, with it's flexible customization capabilities.
FileItemFactory and returns it, obscuring
* from the caller the underlying implementation of this interface.
*
* @param repository The directory within which temporary files will be
* created.
* @return the new FileItemFactory instance.
*/
protected FileItemFactory createFactory(File repository) {
return new DefaultFileItemFactory(threshold, repository);
}
static final String CHARSET_ISO88591 = "ISO-8859-1";
static final String CHARSET_ASCII = "US-ASCII";
static final String CHARSET_UTF8 = "UTF-8";
static final String CHARSET_KOI8_R = "KOI8_R";
static final String CHARSET_WIN1251 = "Cp1251";
static final int SWISS_GERMAN_STUFF_UNICODE [] = {
0x47, 0x72, 0xFC, 0x65, 0x7A, 0x69, 0x5F, 0x7A, 0xE4, 0x6D, 0xE4
};
static final int SWISS_GERMAN_STUFF_ISO8859_1 [] = {
0x47, 0x72, 0xFC, 0x65, 0x7A, 0x69, 0x5F, 0x7A, 0xE4, 0x6D, 0xE4
};
static final int SWISS_GERMAN_STUFF_UTF8 [] = {
0x47, 0x72, 0xC3, 0xBC, 0x65, 0x7A, 0x69, 0x5F, 0x7A, 0xC3, 0xA4,
0x6D, 0xC3, 0xA4
};
static final int RUSSIAN_STUFF_UNICODE [] = {
0x412, 0x441, 0x435, 0x43C, 0x5F, 0x43F, 0x440, 0x438,
0x432, 0x435, 0x442
};
static final int RUSSIAN_STUFF_UTF8 [] = {
0xD0, 0x92, 0xD1, 0x81, 0xD0, 0xB5, 0xD0, 0xBC, 0x5F,
0xD0, 0xBF, 0xD1, 0x80, 0xD0, 0xB8, 0xD0, 0xB2, 0xD0,
0xB5, 0xD1, 0x82
};
static final int RUSSIAN_STUFF_KOI8R [] = {
0xF7, 0xD3, 0xC5, 0xCD, 0x5F, 0xD0, 0xD2, 0xC9, 0xD7,
0xC5, 0xD4
};
static final int RUSSIAN_STUFF_WIN1251 [] = {
0xC2, 0xF1, 0xE5, 0xEC, 0x5F, 0xEF, 0xF0, 0xE8, 0xE2,
0xE5, 0xF2
};
private static String constructString(int[] unicodeChars) {
StringBuilder buffer = new StringBuilder();
if (unicodeChars != null) {
for (int unicodeChar : unicodeChars) {
buffer.append((char) unicodeChar);
}
}
return buffer.toString();
}
/**
* Test construction of content charset.
*/
public void testContentCharSet() throws Exception {
FileItemFactory factory = createFactory(null);
String teststr = constructString(SWISS_GERMAN_STUFF_UNICODE);
FileItem item =
factory.createItem(
"doesnotmatter",
"text/plain; charset=" + CHARSET_ISO88591,
true,
null);
OutputStream outstream = item.getOutputStream();
for (int element : SWISS_GERMAN_STUFF_ISO8859_1) {
outstream.write(element);
}
outstream.close();
assertEquals(teststr, teststr, item.getString());
item =
factory.createItem(
"doesnotmatter",
"text/plain; charset=" + CHARSET_UTF8,
true,
null);
outstream = item.getOutputStream();
for (int element : SWISS_GERMAN_STUFF_UTF8) {
outstream.write(element);
}
outstream.close();
assertEquals(teststr, teststr, item.getString());
teststr = constructString(RUSSIAN_STUFF_UNICODE);
item =
factory.createItem(
"doesnotmatter",
"text/plain; charset=" + CHARSET_KOI8_R,
true,
null);
outstream = item.getOutputStream();
for (int element : RUSSIAN_STUFF_KOI8R) {
outstream.write(element);
}
outstream.close();
assertEquals(teststr, teststr, item.getString());
item =
factory.createItem(
"doesnotmatter",
"text/plain; charset=" + CHARSET_WIN1251,
true,
null);
outstream = item.getOutputStream();
for (int element : RUSSIAN_STUFF_WIN1251) {
outstream.write(element);
}
outstream.close();
assertEquals(teststr, teststr, item.getString());
item =
factory.createItem(
"doesnotmatter",
"text/plain; charset=" + CHARSET_UTF8,
true,
null);
outstream = item.getOutputStream();
for (int element : RUSSIAN_STUFF_UTF8) {
outstream.write(element);
}
outstream.close();
assertEquals(teststr, teststr, item.getString());
}
}
././@LongLink 100644 0 0 150 12274740161 10253 L ustar 0 0 commons-fileupload-1.3.1-src/src/test/java/org/apache/commons/fileupload/DiskFileItemSerializeTest.java commons-fileupload-1.3.1-src/src/test/java/org/apache/commons/fileupload/DiskFileItemSerializeTest.j100644 0 0 23562 12274737401 30756 0 ustar 0 0 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.junit.Test;
/**
* Serialization Unit tests for
* {@link org.apache.commons.fileupload.disk.DiskFileItem}.
*
* @version $Id: DiskFileItemSerializeTest.java 1507048 2013-07-25 16:16:15Z markt $
*/
public class DiskFileItemSerializeTest {
/**
* Content type for regular form items.
*/
private static final String textContentType = "text/plain";
/**
* Very low threshold for testing memory versus disk options.
*/
private static final int threshold = 16;
/**
* Helper method to test creation of a field when a repository is used.
*/
public void testInMemoryObject(byte[] testFieldValueBytes, File repository) {
FileItem item = createFileItem(testFieldValueBytes, repository);
// Check state is as expected
assertTrue("Initial: in memory", item.isInMemory());
assertEquals("Initial: size", item.getSize(), testFieldValueBytes.length);
compareBytes("Initial", item.get(), testFieldValueBytes);
// Serialize & Deserialize
FileItem newItem = (FileItem)serializeDeserialize(item);
// Test deserialized content is as expected
assertTrue("Check in memory", newItem.isInMemory());
compareBytes("Check", testFieldValueBytes, newItem.get());
// Compare FileItem's (except byte[])
compareFileItems(item, newItem);
}
/**
* Helper method to test creation of a field.
*/
private void testInMemoryObject(byte[] testFieldValueBytes) {
testInMemoryObject(testFieldValueBytes, null);
}
/**
* Test creation of a field for which the amount of data falls below the
* configured threshold.
*/
@Test
public void testBelowThreshold() throws Exception {
// Create the FileItem
byte[] testFieldValueBytes = createContentBytes(threshold - 1);
testInMemoryObject(testFieldValueBytes);
}
/**
* Test creation of a field for which the amount of data equals the
* configured threshold.
*/
@Test
public void testThreshold() throws Exception {
// Create the FileItem
byte[] testFieldValueBytes = createContentBytes(threshold);
testInMemoryObject(testFieldValueBytes);
}
/**
* Test creation of a field for which the amount of data falls above the
* configured threshold.
*/
@Test
public void testAboveThreshold() throws Exception {
// Create the FileItem
byte[] testFieldValueBytes = createContentBytes(threshold + 1);
FileItem item = createFileItem(testFieldValueBytes);
// Check state is as expected
assertFalse("Initial: in memory", item.isInMemory());
assertEquals("Initial: size", item.getSize(), testFieldValueBytes.length);
compareBytes("Initial", item.get(), testFieldValueBytes);
// Serialize & Deserialize
FileItem newItem = (FileItem)serializeDeserialize(item);
// Test deserialized content is as expected
assertFalse("Check in memory", newItem.isInMemory());
compareBytes("Check", testFieldValueBytes, newItem.get());
// Compare FileItem's (except byte[])
compareFileItems(item, newItem);
}
/**
* Test serialization and deserialization when repository is not null.
*/
@Test
public void testValidRepository() throws Exception {
// Create the FileItem
byte[] testFieldValueBytes = createContentBytes(threshold);
File repository = new File(System.getProperty("java.io.tmpdir"));
testInMemoryObject(testFieldValueBytes, repository);
}
/**
* Test deserialization fails when repository is not valid.
*/
@Test(expected=IOException.class)
public void testInvalidRepository() throws Exception {
// Create the FileItem
byte[] testFieldValueBytes = createContentBytes(threshold);
File repository = new File(System.getProperty("java.io.tmpdir") + "file");
FileItem item = createFileItem(testFieldValueBytes, repository);
deserialize(serialize(item));
}
/**
* Test deserialization fails when repository contains a null character.
*/
@Test(expected=IOException.class)
public void testInvalidRepositoryWithNullChar() throws Exception {
// Create the FileItem
byte[] testFieldValueBytes = createContentBytes(threshold);
File repository = new File(System.getProperty("java.io.tmpdir") + "\0");
FileItem item = createFileItem(testFieldValueBytes, repository);
deserialize(serialize(item));
}
/**
* Compare FileItem's (except the byte[] content)
*/
private void compareFileItems(FileItem origItem, FileItem newItem) {
assertTrue("Compare: is in Memory", origItem.isInMemory() == newItem.isInMemory());
assertTrue("Compare: is Form Field", origItem.isFormField() == newItem.isFormField());
assertEquals("Compare: Field Name", origItem.getFieldName(), newItem.getFieldName());
assertEquals("Compare: Content Type", origItem.getContentType(), newItem.getContentType());
assertEquals("Compare: File Name", origItem.getName(), newItem.getName());
}
/**
* Compare content bytes.
*/
private void compareBytes(String text, byte[] origBytes, byte[] newBytes) {
assertNotNull("origBytes must not be null", origBytes);
assertNotNull("newBytes must not be null", newBytes);
assertEquals(text + " byte[] length", origBytes.length, newBytes.length);
for (int i = 0; i < origBytes.length; i++) {
assertEquals(text + " byte[" + i + "]", origBytes[i], newBytes[i]);
}
}
/**
* Create content bytes of a specified size.
*/
private byte[] createContentBytes(int size) {
StringBuilder buffer = new StringBuilder(size);
byte count = 0;
for (int i = 0; i < size; i++) {
buffer.append(count+"");
count++;
if (count > 9) {
count = 0;
}
}
return buffer.toString().getBytes();
}
/**
* Create a FileItem with the specfied content bytes and repository.
*/
private FileItem createFileItem(byte[] contentBytes, File repository) {
FileItemFactory factory = new DiskFileItemFactory(threshold, repository);
String textFieldName = "textField";
FileItem item = factory.createItem(
textFieldName,
textContentType,
true,
"My File Name"
);
try {
OutputStream os = item.getOutputStream();
os.write(contentBytes);
os.close();
} catch(IOException e) {
fail("Unexpected IOException" + e);
}
return item;
}
/**
* Create a FileItem with the specfied content bytes.
*/
private FileItem createFileItem(byte[] contentBytes) {
return createFileItem(contentBytes, null);
}
/**
* Do serialization
*/
private ByteArrayOutputStream serialize(Object target) throws Exception {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(target);
oos.flush();
oos.close();
return baos;
}
/**
* Do deserialization
*/
private Object deserialize(ByteArrayOutputStream baos) throws Exception {
Object result = null;
ByteArrayInputStream bais =
new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
result = ois.readObject();
bais.close();
return result;
}
/**
* Do serialization and deserialization.
*/
private Object serializeDeserialize(Object target) {
// Serialize the test object
ByteArrayOutputStream baos = null;
try {
baos = serialize(target);
} catch (Exception e) {
fail("Exception during serialization: " + e);
}
// Deserialize the test object
Object result = null;
try {
result = deserialize(baos);
} catch (Exception e) {
fail("Exception during deserialization: " + e);
}
return result;
}
}
commons-fileupload-1.3.1-src/src/test/java/org/apache/commons/fileupload/FileItemHeadersTest.java 100644 0 0 10170 12274737401 30246 0 ustar 0 0 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.util.Iterator;
import org.apache.commons.fileupload.util.FileItemHeadersImpl;
import org.junit.Test;
/**
* Unit tests {@link FileItemHeaders} and
* {@link FileItemHeadersImpl}.
*
* @version $Id$
*/
public class FileItemHeadersTest {
/**
* @throws Exception
*/
@Test
public void testFileItemHeaders() throws Exception {
FileItemHeadersImpl aMutableFileItemHeaders = new FileItemHeadersImpl();
aMutableFileItemHeaders.addHeader("Content-Disposition", "form-data; name=\"FileItem\"; filename=\"file1.txt\"");
aMutableFileItemHeaders.addHeader("Content-Type", "text/plain");
aMutableFileItemHeaders.addHeader("TestHeader", "headerValue1");
aMutableFileItemHeaders.addHeader("TestHeader", "headerValue2");
aMutableFileItemHeaders.addHeader("TestHeader", "headerValue3");
aMutableFileItemHeaders.addHeader("testheader", "headerValue4");
Iterator-
*
- BASE64("") = "" *
- BASE64("f") = "Zg==" *
- BASE64("fo") = "Zm8=" *
- BASE64("foo") = "Zm9v" *
- BASE64("foob") = "Zm9vYg==" *
- BASE64("fooba") = "Zm9vYmE=" *
- BASE64("foobar") = "Zm9vYmFy" *