/** * $RCSfile: MultipartParamUtils.java,v $ * $Revision: 1.5 $ * $Date: 2003/05/30 14:26:02 $ * * Copyright (C) 1999-2002 CoolServlets, Inc. All rights reserved. * * This software is the proprietary information of CoolServlets, Inc. * Use is subject to license terms. */package com.struts2.framework.util;import javax.activation.*;import javax.mail.*;import javax.mail.internet.*;import javax.servlet.ServletRequest;import java.io.*;import java.util.Enumeration;import java.util.HashMap;import java.util.Map;import java.util.Iterator;/** * This class retrieves web page parameters from a multipart/form-data encoded * HTML form and stores them as key/values pairs. It also stores any parameters * found in the ServletRequest object (non-multipart/form-data parameters). *  * @see ParamUtils */public class MultipartParamUtils {	private Map parameters;	/**	 * Initialize the class with the ServletRequest object and the maximum	 * allowable request size (in bytes).	 * 	 * @param request	 *            the ServletRequest object	 * @param maxRequestSize	 *            the maximum allowable incoming request size, in bytes.	 */	public MultipartParamUtils(ServletRequest request, int maxRequestSize) throws IOException {		// Initialize the internal map of parameter name/value pairs		this.parameters = new HashMap();		String contentType = request.getContentType();		// loop through the request and pull out any multipart text/plain		// values and store them as the parameters		if (contentType != null				&& contentType.startsWith("multipart/form-data")) {			try {				// Put the request's input stream into a Multipart object.				Multipart multipart = new MimeMultipart(new MemoryDataSource(						request.getInputStream(), contentType, maxRequestSize));				// For each part in the multipart object:				for (int i = 0; i < multipart.getCount(); i++) {					Part part = multipart.getBodyPart(i);					// For all headers in this part:					for (Enumeration enum = part.getAllHeaders(); enum							.hasMoreElements();) {						// The part header holds the parameter name						String paramName = ((Header) enum.nextElement())								.getValue();						// If the paramName contains "filename=" then this is						// a file, otherwise we'll treat is as a regular						// parameter.						if (paramName.indexOf("filename=\"") > -1) {							// We have to get both the name= and filename=							// fields.							int nStart = paramName.indexOf("name=\"")									+ "name=\"".length();							int nEnd = paramName.indexOf("\"", nStart);							int fnStart = paramName.indexOf("filename=\"")									+ "filename=\"".length();							int fnEnd = paramName.indexOf("\"", fnStart);							String name = paramName.substring(nStart, nEnd);							String filename = paramName.substring(fnStart,									fnEnd);							// Store the name/file name as one key/value							parameters.put(name, filename);							// Store the name/part content as another							parameters									.put(name + "Data", part.getInputStream());							// Store the name/part contenet type as another							parameters.put(name + "ContentType", part									.getContentType());							// Store the file size as another parameter							parameters.put(name + "Size", new Integer(part									.getSize()));						} else {							// This parameter is not a file, just a normal							// text/plain param.							int nStart = paramName.indexOf("name=\"");							nStart += "name=\"".length();							int nEnd = paramName.lastIndexOf("\"");							if (nStart > -1 && nEnd > -1) {								paramName = paramName.substring(nStart, nEnd);								if (paramName != null) {									Object value = part.getContent();									if (value != null) {										parameters.put(paramName, value												.toString().trim());									}								}							}						}					}				}			} catch (MessagingException e) {			}		}		// Try to add any non-multipart/form-data parameters found in the		// request object to the internal parameter map.		for (Enumeration enum = request.getParameterNames(); enum				.hasMoreElements();) {			String name = (String) enum.nextElement();			parameters.put(name, request.getParameter(name));		}	}	public Iterator getParameterNames() {		return parameters.keySet().iterator();	}	public String getParameter(String name, boolean emptyStringOK) {		if (name == null) {			return null;		}		String value = null;		if (parameters.containsKey(name)) {			value = (parameters.get(name)).toString();			if ("".equals(value) && !emptyStringOK) {				value = null;			}		}		return value;	}	public String getParameter(String name) {		return getParameter(name, false);	}	public int getIntParameter(String name, int defaultValue) {		int value = defaultValue;		String param = getParameter(name);		if (param != null) {			try {				value = Integer.parseInt(param);			} catch (NumberFormatException ignored) {			}		}		return value;	}	public long getLongParameter(String name, long defaultValue) {		long value = defaultValue;		String param = getParameter(name);		if (param != null) {			try {				value = Long.parseLong(param);			} catch (NumberFormatException ignored) {			}		}		return value;	}	public boolean getBooleanParameter(String name) {		String param = getParameter(name);		if (param != null && ("true".equals(param) || "on".equals(param))) {			return true;		}		return false;	}	// Methods for extra multipart parameter attributes	/**	 * Returns an InputStream of the given parameter's data. Will return null if	 * the name is invalid or the parameter is not found.	 */	public InputStream getParameterData(String name) {		if (name == null) {			return null;		}		Object obj = parameters.get(name + "Data");		if (obj != null) {			return (InputStream) obj;		} else {			return null;		}	}	/**	 * Returns the size of the given parameter in bytes or 0 if the parameter is	 * not found.	 */	public int getParameterSize(String name) {		if (name == null) {			return 0;		}		Object obj = parameters.get(name + "Size");		if (obj != null) {			return ((Integer) obj).intValue();		} else {			return 0;		}	}	/**	 * Returns the content type of the named parameter. Returns null if the name	 * is invalid or "text/plain" if the type is unknown.	 */	public String getParameterContentType(String name) {		if (name == null) {			return null;		}		Object obj = parameters.get(name + "ContentType");		if (obj != null) {			return (String) obj;		} else {			return "text/plain";		}	}}class MemoryDataSource implements DataSource {	private String contentType;	private ByteArrayOutputStream buf;	public MemoryDataSource(InputStream in, String contentType,			int maxRequestSize) {		this.contentType = contentType;		buf = new ByteArrayOutputStream();		try {			int data = -1;			// Keep count of how much data we've written in. If it exceeds			// maxRequestSize, stop reading data			int size = 0;			while ((data = in.read()) > -1) {				buf.write(data);				size++;				if (size > maxRequestSize) {					break;				}			}		} catch (Exception e) {		}	}	public String getContentType() {		return contentType;	}	public String getName() {		return "";	}	public InputStream getInputStream() throws IOException {		return new ByteArrayInputStream(buf.toByteArray());	}	public OutputStream getOutputStream() throws IOException {		throw new UnsupportedOperationException();	}}