org.hdiv.config.multipart.AbstractMultipartConfig Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of hdiv-struts-1 Show documentation
Web Application Security Framework
There is a newer version: 3.5.2
/**
 * Copyright 2005-2015 hdiv.org
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * 	http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.hdiv.config.multipart;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

import javax.servlet.ServletContext;

import org.apache.commons.fileupload.FileItem;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hdiv.filter.RequestWrapper;

/**
 * Class containing multipart request configuration and methods initialized from Spring Factory.
 * 
 * @author Gorka Vicente
 */
public abstract class AbstractMultipartConfig implements IMultipartConfig {

	/**
	 * Commons Logging instance.
	 */
	private static Log log = LogFactory.getLog(AbstractMultipartConfig.class);

	/**
	 * The default value for the maximum allowable size, in bytes, of an uploaded file. The value is equivalent to 2MB.
	 */
	public static final long DEFAULT_SIZE_MAX = 2 * 1024 * 1024;

	/**
	 * The default value for the threshold which determines whether an uploaded file will be written to disk or cached
	 * in memory. The value is equivalent to 250KB.
	 */
	public static final int DEFAULT_SIZE_THRESHOLD = 256 * 1024;

	/**
	 * The maximum allowable size, in bytes, of an uploaded file.
	 */
	protected String maxFileSize;

	/**
	 * The temporary working directory to use for file uploads.
	 */
	protected String tempDir = null;

	/**
	 * Converts a size value from a string representation to its numeric value. The string must be of the form nnnm,
	 * where nnn is an arbitrary decimal value, and m is a multiplier. The multiplier must be one of 'K', 'M' and 'G',
	 * representing kilobytes, megabytes and gigabytes respectively. If the size value cannot be converted, for example
	 * due to invalid syntax, the supplied default is returned instead.
	 * 
	 * @param sizeString
	 *            The string representation of the size to be converted.
	 * @param defaultSize
	 *            The value to be returned if the string is invalid.
	 * @return The actual size in bytes.
	 */
	public long convertSizeToBytes(String sizeString, long defaultSize) {

		if(sizeString == null) {
			return defaultSize;
		}
		int multiplier = 1;

		if (sizeString.endsWith("K")) {
			multiplier = 1024;
		} else if (sizeString.endsWith("M")) {
			multiplier = 1024 * 1024;
		} else if (sizeString.endsWith("G")) {
			multiplier = 1024 * 1024 * 1024;
		}
		if (multiplier != 1) {
			sizeString = sizeString.substring(0, sizeString.length() - 1);
		}

		long size = 0;
		try {
			size = Long.parseLong(sizeString);
		} catch (NumberFormatException nfe) {
			log.warn("Invalid format for file size ('" + sizeString + "'). Using default.");
			size = defaultSize;
			multiplier = 1;
		}

		return (size * multiplier);
	}

	/**
	 * Returns the path to the temporary directory to be used for uploaded files which are written to disk. The
	 * directory used is determined from the first of the following to be non-empty.
	 * 
	 * A temp dir explicitly defined using the saveDir attribute of the <multipartConfig> element
	 * in the Spring config file.
	 * The temp dir specified by the javax.servlet.context.tempdir attribute.
	 * 
	 * 
	 * @param servletContext
	 *            servlet context
	 * @return The path to the directory to be used to store uploaded files.
	 */
	public String getRepositoryPath(ServletContext servletContext) {

		// First, look for an explicitly defined temp dir.
		String saveDir = this.tempDir;

		if ((saveDir == null) || saveDir.equals("")) {
			File tempdir = (File) servletContext.getAttribute("javax.servlet.context.tempdir");
			log.info("Unable to find 'saveDir' property setting. Defaulting to javax.servlet.context.tempdir");

			if (tempdir != null) {
				saveDir = tempdir.toString();
			}

			// If none, look for a container specified temp dir.
			if (saveDir == null || saveDir.length() == 0) {
				saveDir = System.getProperty("java.io.tmpdir");
			}

		} else {
			File multipartSaveDir = new File(saveDir);

			if (!multipartSaveDir.exists()) {
				multipartSaveDir.mkdir();
			}
		}

		if (log.isTraceEnabled()) {
			log.trace("File upload temp dir: " + saveDir);
		}

		return saveDir;
	}

	/**
	 * Adds a file parameter to the set of file parameters for this request and also to the list of all parameters.
	 * 
	 * @param request
	 *            The request in which the parameter was specified.
	 * @param item
	 *            The file item for the parameter to add.
	 */
	public void addFileParameter(RequestWrapper request, FileItem item) {

		List values;
		if (request.getFileElements().get(item.getFieldName()) != null) {
			values = (List) request.getFileElements().get(item.getFieldName());
		} else {
			values = new ArrayList();
		}

		values.add(item);
		request.addFileItem(item.getFieldName(), values);
	}

	/**
	 * @param maxFileSize
	 *            The maximum size to set.
	 */
	public void setMaxFileSize(String maxFileSize) {
		this.maxFileSize = maxFileSize;
	}

	/**
	 * @param tempDir
	 *            The tempDir to set.
	 */
	public void setTempDir(String tempDir) {
		this.tempDir = tempDir;
	}

	/**
	 * Returns the maximum allowable size, in bytes, of an uploaded file. The value is obtained from the Spring
	 * configuration.
	 * 
	 * @return The maximum allowable file size, in bytes.
	 */
	protected long getSizeMax() {
		return convertSizeToBytes(this.maxFileSize, AbstractMultipartConfig.DEFAULT_SIZE_MAX);
	}
}