diff --git a/jetty-http/pom.xml b/jetty-http/pom.xml
index 2d0b5735314..cae6d2d1cbb 100644
--- a/jetty-http/pom.xml
+++ b/jetty-http/pom.xml
@@ -23,6 +23,11 @@
jetty-io
${project.version}
+
+ javax.servlet
+ javax.servlet-api
+ provided
+
org.eclipse.jetty.toolchain
jetty-test-helper
diff --git a/jetty-http/src/main/java/org/eclipse/jetty/http/MultiPartInputStreamParser.java b/jetty-http/src/main/java/org/eclipse/jetty/http/MultiPartInputStreamParser.java
new file mode 100644
index 00000000000..01703a8785f
--- /dev/null
+++ b/jetty-http/src/main/java/org/eclipse/jetty/http/MultiPartInputStreamParser.java
@@ -0,0 +1,928 @@
+//
+// ========================================================================
+// Copyright (c) 1995-2018 Mort Bay Consulting Pty. Ltd.
+// ------------------------------------------------------------------------
+// All rights reserved. This program and the accompanying materials
+// are made available under the terms of the Eclipse Public License v1.0
+// and Apache License v2.0 which accompanies this distribution.
+//
+// The Eclipse Public License is available at
+// http://www.eclipse.org/legal/epl-v10.html
+//
+// The Apache License v2.0 is available at
+// http://www.opensource.org/licenses/apache2.0.php
+//
+// You may elect to redistribute this code under either of these licenses.
+// ========================================================================
+//
+
+package org.eclipse.jetty.http;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.FilterInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+
+import javax.servlet.MultipartConfigElement;
+import javax.servlet.ServletInputStream;
+import javax.servlet.http.Part;
+
+import org.eclipse.jetty.util.B64Code;
+import org.eclipse.jetty.util.ByteArrayOutputStream2;
+import org.eclipse.jetty.util.LazyList;
+import org.eclipse.jetty.util.MultiException;
+import org.eclipse.jetty.util.MultiMap;
+import org.eclipse.jetty.util.QuotedStringTokenizer;
+import org.eclipse.jetty.util.ReadLineInputStream;
+import org.eclipse.jetty.util.log.Log;
+import org.eclipse.jetty.util.log.Logger;
+
+
+
+/**
+ * MultiPartInputStream
+ *
+ * Handle a MultiPart Mime input stream, breaking it up on the boundary into files and strings.
+ */
+public class MultiPartInputStreamParser
+{
+ private static final Logger LOG = Log.getLogger(MultiPartInputStreamParser.class);
+ public static final MultipartConfigElement __DEFAULT_MULTIPART_CONFIG = new MultipartConfigElement(System.getProperty("java.io.tmpdir"));
+ public static final MultiMap EMPTY_MAP = new MultiMap<>(Collections.emptyMap());
+ protected InputStream _in;
+ protected MultipartConfigElement _config;
+ protected String _contentType;
+ protected MultiMap _parts;
+ protected Exception _err;
+ protected File _tmpDir;
+ protected File _contextTmpDir;
+ protected boolean _deleteOnExit;
+ protected boolean _writeFilesWithFilenames;
+
+
+
+ public class MultiPart implements Part
+ {
+ protected String _name;
+ protected String _filename;
+ protected File _file;
+ protected OutputStream _out;
+ protected ByteArrayOutputStream2 _bout;
+ protected String _contentType;
+ protected MultiMap _headers;
+ protected long _size = 0;
+ protected boolean _temporary = true;
+
+ public MultiPart (String name, String filename)
+ throws IOException
+ {
+ _name = name;
+ _filename = filename;
+ }
+
+ @Override
+ public String toString()
+ {
+ return String.format("Part{n=%s,fn=%s,ct=%s,s=%d,t=%b,f=%s}",_name,_filename,_contentType,_size,_temporary,_file);
+ }
+ protected void setContentType (String contentType)
+ {
+ _contentType = contentType;
+ }
+
+
+ protected void open()
+ throws IOException
+ {
+ //We will either be writing to a file, if it has a filename on the content-disposition
+ //and otherwise a byte-array-input-stream, OR if we exceed the getFileSizeThreshold, we
+ //will need to change to write to a file.
+ if (isWriteFilesWithFilenames() && _filename != null && _filename.trim().length() > 0)
+ {
+ createFile();
+ }
+ else
+ {
+ //Write to a buffer in memory until we discover we've exceed the
+ //MultipartConfig fileSizeThreshold
+ _out = _bout= new ByteArrayOutputStream2();
+ }
+ }
+
+ protected void close()
+ throws IOException
+ {
+ _out.close();
+ }
+
+
+ protected void write (int b)
+ throws IOException
+ {
+ if (MultiPartInputStreamParser.this._config.getMaxFileSize() > 0 && _size + 1 > MultiPartInputStreamParser.this._config.getMaxFileSize())
+ throw new IllegalStateException ("Multipart Mime part "+_name+" exceeds max filesize");
+
+ if (MultiPartInputStreamParser.this._config.getFileSizeThreshold() > 0 && _size + 1 > MultiPartInputStreamParser.this._config.getFileSizeThreshold() && _file==null)
+ createFile();
+
+ _out.write(b);
+ _size ++;
+ }
+
+ protected void write (byte[] bytes, int offset, int length)
+ throws IOException
+ {
+ if (MultiPartInputStreamParser.this._config.getMaxFileSize() > 0 && _size + length > MultiPartInputStreamParser.this._config.getMaxFileSize())
+ throw new IllegalStateException ("Multipart Mime part "+_name+" exceeds max filesize");
+
+ if (MultiPartInputStreamParser.this._config.getFileSizeThreshold() > 0 && _size + length > MultiPartInputStreamParser.this._config.getFileSizeThreshold() && _file==null)
+ createFile();
+
+ _out.write(bytes, offset, length);
+ _size += length;
+ }
+
+ protected void createFile ()
+ throws IOException
+ {
+ /* Some statics just to make the code below easier to understand
+ * This get optimized away during the compile anyway */
+ final boolean USER = true;
+ final boolean WORLD = false;
+
+ _file = File.createTempFile("MultiPart", "", MultiPartInputStreamParser.this._tmpDir);
+ _file.setReadable(false,WORLD); // (reset) disable it for everyone first
+ _file.setReadable(true,USER); // enable for user only
+
+ if (_deleteOnExit)
+ _file.deleteOnExit();
+ FileOutputStream fos = new FileOutputStream(_file);
+ BufferedOutputStream bos = new BufferedOutputStream(fos);
+
+ if (_size > 0 && _out != null)
+ {
+ //already written some bytes, so need to copy them into the file
+ _out.flush();
+ _bout.writeTo(bos);
+ _out.close();
+ _bout = null;
+ }
+ _out = bos;
+ }
+
+
+
+ protected void setHeaders(MultiMap headers)
+ {
+ _headers = headers;
+ }
+
+ /**
+ * @see javax.servlet.http.Part#getContentType()
+ */
+ @Override
+ public String getContentType()
+ {
+ return _contentType;
+ }
+
+ /**
+ * @see javax.servlet.http.Part#getHeader(java.lang.String)
+ */
+ @Override
+ public String getHeader(String name)
+ {
+ if (name == null)
+ return null;
+ return _headers.getValue(name.toLowerCase(Locale.ENGLISH), 0);
+ }
+
+ /**
+ * @see javax.servlet.http.Part#getHeaderNames()
+ */
+ @Override
+ public Collection getHeaderNames()
+ {
+ return _headers.keySet();
+ }
+
+ /**
+ * @see javax.servlet.http.Part#getHeaders(java.lang.String)
+ */
+ @Override
+ public Collection getHeaders(String name)
+ {
+ return _headers.getValues(name);
+ }
+
+ /**
+ * @see javax.servlet.http.Part#getInputStream()
+ */
+ @Override
+ public InputStream getInputStream() throws IOException
+ {
+ if (_file != null)
+ {
+ //written to a file, whether temporary or not
+ return new BufferedInputStream (new FileInputStream(_file));
+ }
+ else
+ {
+ //part content is in memory
+ return new ByteArrayInputStream(_bout.getBuf(),0,_bout.size());
+ }
+ }
+
+
+ /**
+ * @see javax.servlet.http.Part#getSubmittedFileName()
+ */
+ @Override
+ public String getSubmittedFileName()
+ {
+ return getContentDispositionFilename();
+ }
+
+ public byte[] getBytes()
+ {
+ if (_bout!=null)
+ return _bout.toByteArray();
+ return null;
+ }
+
+ /**
+ * @see javax.servlet.http.Part#getName()
+ */
+ @Override
+ public String getName()
+ {
+ return _name;
+ }
+
+ /**
+ * @see javax.servlet.http.Part#getSize()
+ */
+ @Override
+ public long getSize()
+ {
+ return _size;
+ }
+
+ /**
+ * @see javax.servlet.http.Part#write(java.lang.String)
+ */
+ @Override
+ public void write(String fileName) throws IOException
+ {
+ if (_file == null)
+ {
+ _temporary = false;
+
+ //part data is only in the ByteArrayOutputStream and never been written to disk
+ _file = new File (_tmpDir, fileName);
+
+ BufferedOutputStream bos = null;
+ try
+ {
+ bos = new BufferedOutputStream(new FileOutputStream(_file));
+ _bout.writeTo(bos);
+ bos.flush();
+ }
+ finally
+ {
+ if (bos != null)
+ bos.close();
+ _bout = null;
+ }
+ }
+ else
+ {
+ //the part data is already written to a temporary file, just rename it
+ _temporary = false;
+
+ Path src = _file.toPath();
+ Path target = src.resolveSibling(fileName);
+ Files.move(src, target, StandardCopyOption.REPLACE_EXISTING);
+ _file = target.toFile();
+ }
+ }
+
+ /**
+ * Remove the file, whether or not Part.write() was called on it
+ * (ie no longer temporary)
+ * @see javax.servlet.http.Part#delete()
+ */
+ @Override
+ public void delete() throws IOException
+ {
+ if (_file != null && _file.exists())
+ _file.delete();
+ }
+
+ /**
+ * Only remove tmp files.
+ *
+ * @throws IOException if unable to delete the file
+ */
+ public void cleanUp() throws IOException
+ {
+ if (_temporary && _file != null && _file.exists())
+ _file.delete();
+ }
+
+
+ /**
+ * Get the file
+ * @return the file, if any, the data has been written to.
+ */
+ public File getFile ()
+ {
+ return _file;
+ }
+
+
+ /**
+ * Get the filename from the content-disposition.
+ * @return null or the filename
+ */
+ public String getContentDispositionFilename ()
+ {
+ return _filename;
+ }
+ }
+
+
+
+
+ /**
+ * @param in Request input stream
+ * @param contentType Content-Type header
+ * @param config MultipartConfigElement
+ * @param contextTmpDir javax.servlet.context.tempdir
+ */
+ public MultiPartInputStreamParser (InputStream in, String contentType, MultipartConfigElement config, File contextTmpDir)
+ {
+ _contentType = contentType;
+ _config = config;
+ _contextTmpDir = contextTmpDir;
+ if (_contextTmpDir == null)
+ _contextTmpDir = new File (System.getProperty("java.io.tmpdir"));
+
+ if (_config == null)
+ _config = new MultipartConfigElement(_contextTmpDir.getAbsolutePath());
+
+ if (in instanceof ServletInputStream)
+ {
+ if (((ServletInputStream)in).isFinished())
+ {
+ _parts = EMPTY_MAP;
+ return;
+ }
+ }
+ _in = new ReadLineInputStream(in);
+ }
+
+ /**
+ * Get the already parsed parts.
+ * @return the parts that were parsed
+ */
+ public Collection getParsedParts()
+ {
+ if (_parts == null)
+ return Collections.emptyList();
+
+ Collection> values = _parts.values();
+ List parts = new ArrayList<>();
+ for (List o: values)
+ {
+ List asList = LazyList.getList(o, false);
+ parts.addAll(asList);
+ }
+ return parts;
+ }
+
+ /**
+ * Delete any tmp storage for parts, and clear out the parts list.
+ *
+ * @throws MultiException if unable to delete the parts
+ */
+ public void deleteParts ()
+ throws MultiException
+ {
+ Collection parts = getParsedParts();
+ MultiException err = new MultiException();
+ for (Part p:parts)
+ {
+ try
+ {
+ ((MultiPartInputStreamParser.MultiPart)p).cleanUp();
+ }
+ catch(Exception e)
+ {
+ err.add(e);
+ }
+ }
+ _parts.clear();
+
+ err.ifExceptionThrowMulti();
+ }
+
+
+ /**
+ * Parse, if necessary, the multipart data and return the list of Parts.
+ *
+ * @return the parts
+ * @throws IOException if unable to get the parts
+ */
+ public Collection getParts()
+ throws IOException
+ {
+ parse();
+ throwIfError();
+
+
+ Collection> values = _parts.values();
+ List parts = new ArrayList<>();
+ for (List o: values)
+ {
+ List asList = LazyList.getList(o, false);
+ parts.addAll(asList);
+ }
+ return parts;
+ }
+
+
+ /**
+ * Get the named Part.
+ *
+ * @param name the part name
+ * @return the parts
+ * @throws IOException if unable to get the part
+ */
+ public Part getPart(String name)
+ throws IOException
+ {
+ parse();
+ throwIfError();
+ return _parts.getValue(name, 0);
+ }
+
+ /**
+ * Throws an exception if one has been latched.
+ *
+ * @throws IOException the exception (if present)
+ */
+ protected void throwIfError ()
+ throws IOException
+ {
+ if (_err != null)
+ {
+ if (_err instanceof IOException)
+ throw (IOException)_err;
+ if (_err instanceof IllegalStateException)
+ throw (IllegalStateException)_err;
+ throw new IllegalStateException(_err);
+ }
+ }
+
+ /**
+ * Parse, if necessary, the multipart stream.
+ *
+ */
+ protected void parse ()
+ {
+ //have we already parsed the input?
+ if (_parts != null || _err != null)
+ return;
+
+
+ //initialize
+ long total = 0; //keep running total of size of bytes read from input and throw an exception if exceeds MultipartConfigElement._maxRequestSize
+ _parts = new MultiMap<>();
+
+ //if its not a multipart request, don't parse it
+ if (_contentType == null || !_contentType.startsWith("multipart/form-data"))
+ return;
+
+ try
+ {
+ //sort out the location to which to write the files
+
+ if (_config.getLocation() == null)
+ _tmpDir = _contextTmpDir;
+ else if ("".equals(_config.getLocation()))
+ _tmpDir = _contextTmpDir;
+ else
+ {
+ File f = new File (_config.getLocation());
+ if (f.isAbsolute())
+ _tmpDir = f;
+ else
+ _tmpDir = new File (_contextTmpDir, _config.getLocation());
+ }
+
+ if (!_tmpDir.exists())
+ _tmpDir.mkdirs();
+
+ String contentTypeBoundary = "";
+ int bstart = _contentType.indexOf("boundary=");
+ if (bstart >= 0)
+ {
+ int bend = _contentType.indexOf(";", bstart);
+ bend = (bend < 0? _contentType.length(): bend);
+ contentTypeBoundary = QuotedStringTokenizer.unquote(value(_contentType.substring(bstart,bend)).trim());
+ }
+
+ String boundary="--"+contentTypeBoundary;
+ String lastBoundary=boundary+"--";
+ byte[] byteBoundary=lastBoundary.getBytes(StandardCharsets.ISO_8859_1);
+
+ // Get first boundary
+ String line = null;
+ try
+ {
+ line=((ReadLineInputStream)_in).readLine();
+ }
+ catch (IOException e)
+ {
+ LOG.warn("Badly formatted multipart request");
+ throw e;
+ }
+
+ if (line == null)
+ throw new IOException("Missing content for multipart request");
+
+ boolean badFormatLogged = false;
+ line=line.trim();
+ while (line != null && !line.equals(boundary) && !line.equals(lastBoundary))
+ {
+ if (!badFormatLogged)
+ {
+ LOG.warn("Badly formatted multipart request");
+ badFormatLogged = true;
+ }
+ line=((ReadLineInputStream)_in).readLine();
+ line=(line==null?line:line.trim());
+ }
+
+ if (line == null || line.length() == 0)
+ throw new IOException("Missing initial multi part boundary");
+
+ // Empty multipart.
+ if (line.equals(lastBoundary))
+ return;
+
+ // Read each part
+ boolean lastPart=false;
+
+ outer:while(!lastPart)
+ {
+ String contentDisposition=null;
+ String contentType=null;
+ String contentTransferEncoding=null;
+
+ MultiMap headers = new MultiMap<>();
+ while(true)
+ {
+ line=((ReadLineInputStream)_in).readLine();
+
+ //No more input
+ if(line==null)
+ break outer;
+
+ //end of headers:
+ if("".equals(line))
+ break;
+
+ total += line.length();
+ if (_config.getMaxRequestSize() > 0 && total > _config.getMaxRequestSize())
+ throw new IllegalStateException ("Request exceeds maxRequestSize ("+_config.getMaxRequestSize()+")");
+
+ //get content-disposition and content-type
+ int c=line.indexOf(':',0);
+ if(c>0)
+ {
+ String key=line.substring(0,c).trim().toLowerCase(Locale.ENGLISH);
+ String value=line.substring(c+1,line.length()).trim();
+ headers.put(key, value);
+ if (key.equalsIgnoreCase("content-disposition"))
+ contentDisposition=value;
+ if (key.equalsIgnoreCase("content-type"))
+ contentType = value;
+ if(key.equals("content-transfer-encoding"))
+ contentTransferEncoding=value;
+ }
+ }
+
+ // Extract content-disposition
+ boolean form_data=false;
+ if(contentDisposition==null)
+ {
+ throw new IOException("Missing content-disposition");
+ }
+
+ QuotedStringTokenizer tok=new QuotedStringTokenizer(contentDisposition,";", false, true);
+ String name=null;
+ String filename=null;
+ while(tok.hasMoreTokens())
+ {
+ String t=tok.nextToken().trim();
+ String tl=t.toLowerCase(Locale.ENGLISH);
+ if(t.startsWith("form-data"))
+ form_data=true;
+ else if(tl.startsWith("name="))
+ name=value(t);
+ else if(tl.startsWith("filename="))
+ filename=filenameValue(t);
+ }
+
+ // Check disposition
+ if(!form_data)
+ {
+ continue;
+ }
+ //It is valid for reset and submit buttons to have an empty name.
+ //If no name is supplied, the browser skips sending the info for that field.
+ //However, if you supply the empty string as the name, the browser sends the
+ //field, with name as the empty string. So, only continue this loop if we
+ //have not yet seen a name field.
+ if(name==null)
+ {
+ continue;
+ }
+
+ //Have a new Part
+ MultiPart part = new MultiPart(name, filename);
+ part.setHeaders(headers);
+ part.setContentType(contentType);
+ _parts.add(name, part);
+ part.open();
+
+ InputStream partInput = null;
+ if ("base64".equalsIgnoreCase(contentTransferEncoding))
+ {
+ partInput = new Base64InputStream((ReadLineInputStream)_in);
+ }
+ else if ("quoted-printable".equalsIgnoreCase(contentTransferEncoding))
+ {
+ partInput = new FilterInputStream(_in)
+ {
+ @Override
+ public int read() throws IOException
+ {
+ int c = in.read();
+ if (c >= 0 && c == '=')
+ {
+ int hi = in.read();
+ int lo = in.read();
+ if (hi < 0 || lo < 0)
+ {
+ throw new IOException("Unexpected end to quoted-printable byte");
+ }
+ char[] chars = new char[] { (char)hi, (char)lo };
+ c = Integer.parseInt(new String(chars),16);
+ }
+ return c;
+ }
+ };
+ }
+ else
+ partInput = _in;
+
+
+ try
+ {
+ int state=-2;
+ int c;
+ boolean cr=false;
+ boolean lf=false;
+
+ // loop for all lines
+ while(true)
+ {
+ int b=0;
+ while((c=(state!=-2)?state:partInput.read())!=-1)
+ {
+ total ++;
+ if (_config.getMaxRequestSize() > 0 && total > _config.getMaxRequestSize())
+ throw new IllegalStateException("Request exceeds maxRequestSize ("+_config.getMaxRequestSize()+")");
+
+ state=-2;
+
+ // look for CR and/or LF
+ if(c==13||c==10)
+ {
+ if(c==13)
+ {
+ partInput.mark(1);
+ int tmp=partInput.read();
+ if (tmp!=10)
+ partInput.reset();
+ else
+ state=tmp;
+ }
+ break;
+ }
+
+ // Look for boundary
+ if(b>=0&&b0)
+ part.write(byteBoundary,0,b);
+
+ b=-1;
+ part.write(c);
+ }
+ }
+
+ // Check for incomplete boundary match, writing out the chars we matched along the way
+ if((b>0&&b0||c==-1)
+ {
+
+ if(b==byteBoundary.length)
+ lastPart=true;
+ if(state==10)
+ state=-2;
+ break;
+ }
+
+ // handle CR LF
+ if(cr)
+ part.write(13);
+
+ if(lf)
+ part.write(10);
+
+ cr=(c==13);
+ lf=(c==10||state==10);
+ if(state==10)
+ state=-2;
+ }
+ }
+ finally
+ {
+ part.close();
+ }
+ }
+ if (lastPart)
+ {
+ while(line!=null)
+ line=((ReadLineInputStream)_in).readLine();
+ }
+ else
+ throw new IOException("Incomplete parts");
+ }
+ catch (Exception e)
+ {
+ _err = e;
+ }
+ }
+
+ public void setDeleteOnExit(boolean deleteOnExit)
+ {
+ _deleteOnExit = deleteOnExit;
+ }
+
+ public void setWriteFilesWithFilenames (boolean writeFilesWithFilenames)
+ {
+ _writeFilesWithFilenames = writeFilesWithFilenames;
+ }
+
+ public boolean isWriteFilesWithFilenames ()
+ {
+ return _writeFilesWithFilenames;
+ }
+
+ public boolean isDeleteOnExit()
+ {
+ return _deleteOnExit;
+ }
+
+
+ /* ------------------------------------------------------------ */
+ private String value(String nameEqualsValue)
+ {
+ int idx = nameEqualsValue.indexOf('=');
+ String value = nameEqualsValue.substring(idx+1).trim();
+ return QuotedStringTokenizer.unquoteOnly(value);
+ }
+
+
+ /* ------------------------------------------------------------ */
+ private String filenameValue(String nameEqualsValue)
+ {
+ int idx = nameEqualsValue.indexOf('=');
+ String value = nameEqualsValue.substring(idx+1).trim();
+
+ if (value.matches(".??[a-z,A-Z]\\:\\\\[^\\\\].*"))
+ {
+ //incorrectly escaped IE filenames that have the whole path
+ //we just strip any leading & trailing quotes and leave it as is
+ char first=value.charAt(0);
+ if (first=='"' || first=='\'')
+ value=value.substring(1);
+ char last=value.charAt(value.length()-1);
+ if (last=='"' || last=='\'')
+ value = value.substring(0,value.length()-1);
+
+ return value;
+ }
+ else
+ //unquote the string, but allow any backslashes that don't
+ //form a valid escape sequence to remain as many browsers
+ //even on *nix systems will not escape a filename containing
+ //backslashes
+ return QuotedStringTokenizer.unquoteOnly(value, true);
+ }
+
+
+
+ private static class Base64InputStream extends InputStream
+ {
+ ReadLineInputStream _in;
+ String _line;
+ byte[] _buffer;
+ int _pos;
+
+
+ public Base64InputStream(ReadLineInputStream rlis)
+ {
+ _in = rlis;
+ }
+
+ @Override
+ public int read() throws IOException
+ {
+ if (_buffer==null || _pos>= _buffer.length)
+ {
+ //Any CR and LF will be consumed by the readLine() call.
+ //We need to put them back into the bytes returned from this
+ //method because the parsing of the multipart content uses them
+ //as markers to determine when we've reached the end of a part.
+ _line = _in.readLine();
+ if (_line==null)
+ return -1; //nothing left
+ if (_line.startsWith("--"))
+ _buffer=(_line+"\r\n").getBytes(); //boundary marking end of part
+ else if (_line.length()==0)
+ _buffer="\r\n".getBytes(); //blank line
+ else
+ {
+ ByteArrayOutputStream baos = new ByteArrayOutputStream((4*_line.length()/3)+2);
+ B64Code.decode(_line, baos);
+ baos.write(13);
+ baos.write(10);
+ _buffer = baos.toByteArray();
+ }
+
+ _pos=0;
+ }
+
+ return _buffer[_pos++];
+ }
+ }
+}
diff --git a/jetty-http/src/test/java/org/eclipse/jetty/http/MultiPartInputStreamTest.java b/jetty-http/src/test/java/org/eclipse/jetty/http/MultiPartInputStreamTest.java
new file mode 100644
index 00000000000..e833e16d1cb
--- /dev/null
+++ b/jetty-http/src/test/java/org/eclipse/jetty/http/MultiPartInputStreamTest.java
@@ -0,0 +1,1076 @@
+//
+// ========================================================================
+// Copyright (c) 1995-2018 Mort Bay Consulting Pty. Ltd.
+// ------------------------------------------------------------------------
+// All rights reserved. This program and the accompanying materials
+// are made available under the terms of the Eclipse Public License v1.0
+// and Apache License v2.0 which accompanies this distribution.
+//
+// The Eclipse Public License is available at
+// http://www.eclipse.org/legal/epl-v10.html
+//
+// The Apache License v2.0 is available at
+// http://www.opensource.org/licenses/apache2.0.php
+//
+// You may elect to redistribute this code under either of these licenses.
+// ========================================================================
+//
+
+package org.eclipse.jetty.http;
+
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.not;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.hamcrest.Matchers.nullValue;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThat;
+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.InputStream;
+import java.util.Collection;
+import java.util.concurrent.TimeUnit;
+
+import javax.servlet.MultipartConfigElement;
+import javax.servlet.ReadListener;
+import javax.servlet.ServletException;
+import javax.servlet.ServletInputStream;
+import javax.servlet.http.Part;
+
+import org.eclipse.jetty.http.MultiPartInputStreamParser.MultiPart;
+import org.eclipse.jetty.util.B64Code;
+import org.eclipse.jetty.util.IO;
+import org.hamcrest.Matchers;
+import org.junit.Test;
+
+/**
+ * MultiPartInputStreamTest
+ *
+ *
+ */
+public class MultiPartInputStreamTest
+{
+ private static final String FILENAME = "stuff.txt";
+ protected String _contentType = "multipart/form-data, boundary=AaB03x";
+ protected String _multi = createMultipartRequestString(FILENAME);
+ protected String _dirname = System.getProperty("java.io.tmpdir")+File.separator+"myfiles-"+TimeUnit.NANOSECONDS.toMillis(System.nanoTime());
+ protected File _tmpDir = new File(_dirname);
+
+ public MultiPartInputStreamTest ()
+ {
+ _tmpDir.deleteOnExit();
+ }
+
+ @Test
+ public void testBadMultiPartRequest()
+ throws Exception
+ {
+ String boundary = "X0Y0";
+ String str = "--" + boundary + "\r\n"+
+ "Content-Disposition: form-data; name=\"fileup\"; filename=\"test.upload\"\r\n"+
+ "Content-Type: application/octet-stream\r\n\r\n"+
+ "How now brown cow."+
+ "\r\n--" + boundary + "-\r\n\r\n";
+
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 1024, 3072, 50);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(str.getBytes()),
+ "multipart/form-data, boundary="+boundary,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ try
+ {
+ mpis.getParts();
+ fail ("Multipart incomplete");
+ }
+ catch (IOException e)
+ {
+ assertTrue(e.getMessage().startsWith("Incomplete"));
+ }
+ }
+
+
+ @Test
+ public void testFinalBoundaryOnly()
+ throws Exception
+ {
+ String delimiter = "\r\n";
+ final String boundary = "MockMultiPartTestBoundary";
+
+
+ // Malformed multipart request body containing only an arbitrary string of text, followed by the final boundary marker, delimited by empty lines.
+ String str =
+ delimiter +
+ "Hello world" +
+ delimiter + // Two delimiter markers, which make an empty line.
+ delimiter +
+ "--" + boundary + "--" + delimiter;
+
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 1024, 3072, 50);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(str.getBytes()),
+ "multipart/form-data, boundary="+boundary,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ Collection parts = mpis.getParts();
+ assertTrue(mpis.getParts().isEmpty());
+ }
+
+
+
+ @Test
+ public void testEmpty()
+ throws Exception
+ {
+ String delimiter = "\r\n";
+ final String boundary = "MockMultiPartTestBoundary";
+
+ String str =
+ delimiter +
+ "--" + boundary + "--" + delimiter;
+
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 1024, 3072, 50);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(str.getBytes()),
+ "multipart/form-data, boundary="+boundary,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ assertTrue(mpis.getParts().isEmpty());
+ }
+
+ @Test
+ public void testNoBoundaryRequest()
+ throws Exception
+ {
+ String str = "--\r\n"+
+ "Content-Disposition: form-data; name=\"fileName\"\r\n"+
+ "Content-Type: text/plain; charset=US-ASCII\r\n"+
+ "Content-Transfer-Encoding: 8bit\r\n"+
+ "\r\n"+
+ "abc\r\n"+
+ "--\r\n"+
+ "Content-Disposition: form-data; name=\"desc\"\r\n"+
+ "Content-Type: text/plain; charset=US-ASCII\r\n"+
+ "Content-Transfer-Encoding: 8bit\r\n"+
+ "\r\n"+
+ "123\r\n"+
+ "--\r\n"+
+ "Content-Disposition: form-data; name=\"title\"\r\n"+
+ "Content-Type: text/plain; charset=US-ASCII\r\n"+
+ "Content-Transfer-Encoding: 8bit\r\n"+
+ "\r\n"+
+ "ttt\r\n"+
+ "--\r\n"+
+ "Content-Disposition: form-data; name=\"datafile5239138112980980385.txt\"; filename=\"datafile5239138112980980385.txt\"\r\n"+
+ "Content-Type: application/octet-stream; charset=ISO-8859-1\r\n"+
+ "Content-Transfer-Encoding: binary\r\n"+
+ "\r\n"+
+ "000\r\n"+
+ "----\r\n";
+
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 1024, 3072, 50);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(str.getBytes()),
+ "multipart/form-data",
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ Collection parts = mpis.getParts();
+ assertThat(parts.size(), is(4));
+
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ Part fileName = mpis.getPart("fileName");
+ assertThat(fileName, notNullValue());
+ assertThat(fileName.getSize(), is(3L));
+ IO.copy(fileName.getInputStream(), baos);
+ assertThat(baos.toString("US-ASCII"), is("abc"));
+
+ baos = new ByteArrayOutputStream();
+ Part desc = mpis.getPart("desc");
+ assertThat(desc, notNullValue());
+ assertThat(desc.getSize(), is(3L));
+ IO.copy(desc.getInputStream(), baos);
+ assertThat(baos.toString("US-ASCII"), is("123"));
+
+ baos = new ByteArrayOutputStream();
+ Part title = mpis.getPart("title");
+ assertThat(title, notNullValue());
+ assertThat(title.getSize(), is(3L));
+ IO.copy(title.getInputStream(), baos);
+ assertThat(baos.toString("US-ASCII"), is("ttt"));
+ }
+
+ @Test
+ public void testNonMultiPartRequest()
+ throws Exception
+ {
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 1024, 3072, 50);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(_multi.getBytes()),
+ "Content-type: text/plain",
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ assertTrue(mpis.getParts().isEmpty());
+ }
+
+ @Test
+ public void testNoBody()
+ throws Exception
+ {
+ String body = "";
+
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 1024, 3072, 50);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(body.getBytes()),
+ _contentType,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ try
+ {
+ mpis.getParts();
+ fail ("Multipart missing body");
+ }
+ catch (IOException e)
+ {
+ assertTrue(e.getMessage().startsWith("Missing content"));
+ }
+ }
+
+
+ @Test
+ public void testBodyAlreadyConsumed()
+ throws Exception
+ {
+ ServletInputStream is = new ServletInputStream() {
+
+ @Override
+ public boolean isFinished()
+ {
+ return true;
+ }
+
+ @Override
+ public boolean isReady()
+ {
+ return false;
+ }
+
+ @Override
+ public void setReadListener(ReadListener readListener)
+ {
+ }
+
+ @Override
+ public int read() throws IOException
+ {
+ return 0;
+ }
+
+ };
+
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 1024, 3072, 50);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(is,
+ _contentType,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ Collection parts = mpis.getParts();
+ assertEquals(0, parts.size());
+ }
+
+
+
+ @Test
+ public void testWhitespaceBodyWithCRLF()
+ throws Exception
+ {
+ String whitespace = " \n\n\n\r\n\r\n\r\n\r\n";
+
+
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 1024, 3072, 50);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(whitespace.getBytes()),
+ _contentType,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ try
+ {
+ mpis.getParts();
+ fail ("Multipart missing body");
+ }
+ catch (IOException e)
+ {
+ assertTrue(e.getMessage().startsWith("Missing initial"));
+ }
+ }
+
+ @Test
+ public void testWhitespaceBody()
+ throws Exception
+ {
+ String whitespace = " ";
+
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 1024, 3072, 50);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(whitespace.getBytes()),
+ _contentType,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ try
+ {
+ mpis.getParts();
+ fail ("Multipart missing body");
+ }
+ catch (IOException e)
+ {
+ assertTrue(e.getMessage().startsWith("Missing initial"));
+ }
+ }
+
+ @Test
+ public void testLeadingWhitespaceBodyWithCRLF()
+ throws Exception
+ {
+ String body = " \n\n\n\r\n\r\n\r\n\r\n"+
+ "--AaB03x\r\n"+
+ "content-disposition: form-data; name=\"field1\"\r\n"+
+ "\r\n"+
+ "Joe Blow\r\n"+
+ "--AaB03x\r\n"+
+ "content-disposition: form-data; name=\"stuff\"; filename=\"" + "foo.txt" + "\"\r\n"+
+ "Content-Type: text/plain\r\n"+
+ "\r\n"+"aaaa"+
+ "bbbbb"+"\r\n" +
+ "--AaB03x--\r\n";
+
+
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 1024, 3072, 50);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(body.getBytes()),
+ _contentType,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+
+ Collection parts = mpis.getParts();
+ assertThat(parts, notNullValue());
+ assertThat(parts.size(), is(2));
+ Part field1 = mpis.getPart("field1");
+ assertThat(field1, notNullValue());
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ IO.copy(field1.getInputStream(), baos);
+ assertThat(baos.toString("US-ASCII"), is("Joe Blow"));
+
+ Part stuff = mpis.getPart("stuff");
+ assertThat(stuff, notNullValue());
+ baos = new ByteArrayOutputStream();
+ IO.copy(stuff.getInputStream(), baos);
+ assertTrue(baos.toString("US-ASCII").contains("aaaa"));
+ }
+
+
+
+ @Test
+ public void testLeadingWhitespaceBodyWithoutCRLF()
+ throws Exception
+ {
+ String body = " "+
+ "--AaB03x\r\n"+
+ "content-disposition: form-data; name=\"field1\"\r\n"+
+ "\r\n"+
+ "Joe Blow\r\n"+
+ "--AaB03x\r\n"+
+ "content-disposition: form-data; name=\"stuff\"; filename=\"" + "foo.txt" + "\"\r\n"+
+ "Content-Type: text/plain\r\n"+
+ "\r\n"+"aaaa"+
+ "bbbbb"+"\r\n" +
+ "--AaB03x--\r\n";
+
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 1024, 3072, 50);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(body.getBytes()),
+ _contentType,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+
+ Collection parts = mpis.getParts();
+ assertThat(parts, notNullValue());
+ assertThat(parts.size(), is(2));
+ Part field1 = mpis.getPart("field1");
+ assertThat(field1, notNullValue());
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ IO.copy(field1.getInputStream(), baos);
+ assertThat(baos.toString("US-ASCII"), is("Joe Blow"));
+
+ Part stuff = mpis.getPart("stuff");
+ assertThat(stuff, notNullValue());
+ baos = new ByteArrayOutputStream();
+ IO.copy(stuff.getInputStream(), baos);
+ assertTrue(baos.toString("US-ASCII").contains("bbbbb"));
+ }
+
+
+
+
+
+
+ @Test
+ public void testNoLimits()
+ throws Exception
+ {
+ MultipartConfigElement config = new MultipartConfigElement(_dirname);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(_multi.getBytes()),
+ _contentType,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ Collection parts = mpis.getParts();
+ assertFalse(parts.isEmpty());
+ }
+
+ @Test
+ public void testRequestTooBig ()
+ throws Exception
+ {
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 60, 100, 50);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(_multi.getBytes()),
+ _contentType,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ Collection parts = null;
+ try
+ {
+ parts = mpis.getParts();
+ fail("Request should have exceeded maxRequestSize");
+ }
+ catch (IllegalStateException e)
+ {
+ assertTrue(e.getMessage().startsWith("Request exceeds maxRequestSize"));
+ }
+ }
+
+
+ @Test
+ public void testRequestTooBigThrowsErrorOnGetParts ()
+ throws Exception
+ {
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 60, 100, 50);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(_multi.getBytes()),
+ _contentType,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ Collection parts = null;
+
+ //cause parsing
+ try
+ {
+ parts = mpis.getParts();
+ fail("Request should have exceeded maxRequestSize");
+ }
+ catch (IllegalStateException e)
+ {
+ assertTrue(e.getMessage().startsWith("Request exceeds maxRequestSize"));
+ }
+
+ //try again
+ try
+ {
+ parts = mpis.getParts();
+ fail("Request should have exceeded maxRequestSize");
+ }
+ catch (IllegalStateException e)
+ {
+ assertTrue(e.getMessage().startsWith("Request exceeds maxRequestSize"));
+ }
+ }
+
+ @Test
+ public void testFileTooBig()
+ throws Exception
+ {
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 40, 1024, 30);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(_multi.getBytes()),
+ _contentType,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ Collection parts = null;
+ try
+ {
+ parts = mpis.getParts();
+ fail("stuff.txt should have been larger than maxFileSize");
+ }
+ catch (IllegalStateException e)
+ {
+ assertTrue(e.getMessage().startsWith("Multipart Mime part"));
+ }
+ }
+
+ @Test
+ public void testFileTooBigThrowsErrorOnGetParts()
+ throws Exception
+ {
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 40, 1024, 30);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(_multi.getBytes()),
+ _contentType,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ Collection parts = null;
+ try
+ {
+ parts = mpis.getParts(); //caused parsing
+ fail("stuff.txt should have been larger than maxFileSize");
+ }
+ catch (IllegalStateException e)
+ {
+ assertTrue(e.getMessage().startsWith("Multipart Mime part"));
+ }
+
+ //test again after the parsing
+ try
+ {
+ parts = mpis.getParts(); //caused parsing
+ fail("stuff.txt should have been larger than maxFileSize");
+ }
+ catch (IllegalStateException e)
+ {
+ assertTrue(e.getMessage().startsWith("Multipart Mime part"));
+ }
+ }
+
+
+
+ @Test
+ public void testPartFileNotDeleted () throws Exception
+ {
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 1024, 3072, 50);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(createMultipartRequestString("tptfd").getBytes()),
+ _contentType,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ Collection parts = mpis.getParts();
+
+ MultiPart part = (MultiPart)mpis.getPart("stuff");
+ File stuff = ((MultiPartInputStreamParser.MultiPart)part).getFile();
+ assertThat(stuff,notNullValue()); // longer than 100 bytes, should already be a tmp file
+ part.write("tptfd.txt");
+ File tptfd = new File (_dirname+File.separator+"tptfd.txt");
+ assertThat(tptfd.exists(), is(true));
+ assertThat(stuff.exists(), is(false)); //got renamed
+ part.cleanUp();
+ assertThat(tptfd.exists(), is(true)); //explicitly written file did not get removed after cleanup
+ tptfd.deleteOnExit(); //clean up test
+ }
+
+ @Test
+ public void testPartTmpFileDeletion () throws Exception
+ {
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 1024, 3072, 50);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(createMultipartRequestString("tptfd").getBytes()),
+ _contentType,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ Collection parts = mpis.getParts();
+
+ MultiPart part = (MultiPart)mpis.getPart("stuff");
+ File stuff = ((MultiPartInputStreamParser.MultiPart)part).getFile();
+ assertThat(stuff,notNullValue()); // longer than 100 bytes, should already be a tmp file
+ assertThat (stuff.exists(), is(true));
+ part.cleanUp();
+ assertThat(stuff.exists(), is(false)); //tmp file was removed after cleanup
+ }
+
+ @Test
+ public void testLFOnlyRequest()
+ throws Exception
+ {
+ String str = "--AaB03x\n"+
+ "content-disposition: form-data; name=\"field1\"\n"+
+ "\n"+
+ "Joe Blow\n"+
+ "--AaB03x\n"+
+ "content-disposition: form-data; name=\"field2\"\n"+
+ "\n"+
+ "Other\n"+
+ "--AaB03x--\n";
+
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 1024, 3072, 50);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(str.getBytes()),
+ _contentType,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ Collection parts = mpis.getParts();
+ assertThat(parts.size(), is(2));
+ Part p1 = mpis.getPart("field1");
+ assertThat(p1, notNullValue());
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ IO.copy(p1.getInputStream(), baos);
+ assertThat(baos.toString("UTF-8"), is("Joe Blow"));
+
+ Part p2 = mpis.getPart("field2");
+ assertThat(p2, notNullValue());
+ baos = new ByteArrayOutputStream();
+ IO.copy(p2.getInputStream(), baos);
+ assertThat(baos.toString("UTF-8"), is("Other"));
+ }
+
+ @Test
+ public void testCROnlyRequest()
+ throws Exception
+ {
+ String str = "--AaB03x\r"+
+ "content-disposition: form-data; name=\"field1\"\r"+
+ "\r"+
+ "Joe Blow\r"+
+ "--AaB03x\r"+
+ "content-disposition: form-data; name=\"field2\"\r"+
+ "\r"+
+ "Other\r"+
+ "--AaB03x--\r";
+
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 1024, 3072, 50);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(str.getBytes()),
+ _contentType,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ Collection parts = mpis.getParts();
+ assertThat(parts.size(), is(2));
+
+ assertThat(parts.size(), is(2));
+ Part p1 = mpis.getPart("field1");
+ assertThat(p1, notNullValue());
+
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ IO.copy(p1.getInputStream(), baos);
+ assertThat(baos.toString("UTF-8"), is("Joe Blow"));
+
+ Part p2 = mpis.getPart("field2");
+ assertThat(p2, notNullValue());
+ baos = new ByteArrayOutputStream();
+ IO.copy(p2.getInputStream(), baos);
+ assertThat(baos.toString("UTF-8"), is("Other"));
+ }
+
+ @Test
+ public void testCRandLFMixRequest()
+ throws Exception
+ {
+ String str = "--AaB03x\r"+
+ "content-disposition: form-data; name=\"field1\"\r"+
+ "\r"+
+ "\nJoe Blow\n"+
+ "\r"+
+ "--AaB03x\r"+
+ "content-disposition: form-data; name=\"field2\"\r"+
+ "\r"+
+ "Other\r"+
+ "--AaB03x--\r";
+
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 1024, 3072, 50);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(str.getBytes()),
+ _contentType,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ Collection parts = mpis.getParts();
+ assertThat(parts.size(), is(2));
+
+ Part p1 = mpis.getPart("field1");
+ assertThat(p1, notNullValue());
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ IO.copy(p1.getInputStream(), baos);
+ assertThat(baos.toString("UTF-8"), is("\nJoe Blow\n"));
+
+ Part p2 = mpis.getPart("field2");
+ assertThat(p2, notNullValue());
+ baos = new ByteArrayOutputStream();
+ IO.copy(p2.getInputStream(), baos);
+ assertThat(baos.toString("UTF-8"), is("Other"));
+ }
+
+ @Test
+ public void testBufferOverflowNoCRLF () throws Exception
+ {
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ baos.write("--AaB03x".getBytes());
+ for (int i=0; i< 8500; i++) //create content that will overrun default buffer size of BufferedInputStream
+ {
+ baos.write('a');
+ }
+
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 1024, 3072, 50);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(baos.toByteArray()),
+ _contentType,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ try
+ {
+ mpis.getParts();
+ fail ("Multipart buffer overrun");
+ }
+ catch (IOException e)
+ {
+ assertTrue(e.getMessage().startsWith("Buffer size exceeded"));
+ }
+
+ }
+
+ @Test
+ public void testCharsetEncoding () throws Exception
+ {
+ String contentType = "multipart/form-data; boundary=TheBoundary; charset=ISO-8859-1";
+ String str = "--TheBoundary\r"+
+ "content-disposition: form-data; name=\"field1\"\r"+
+ "\r"+
+ "\nJoe Blow\n"+
+ "\r"+
+ "--TheBoundary--\r";
+
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 1024, 3072, 50);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(str.getBytes()),
+ contentType,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ Collection parts = mpis.getParts();
+ assertThat(parts.size(), is(1));
+ }
+
+
+ @Test
+ public void testBadlyEncodedFilename() throws Exception
+ {
+
+ String contents = "--AaB03x\r\n"+
+ "content-disposition: form-data; name=\"stuff\"; filename=\"" +"Taken on Aug 22 \\ 2012.jpg" + "\"\r\n"+
+ "Content-Type: text/plain\r\n"+
+ "\r\n"+"stuff"+
+ "aaa"+"\r\n" +
+ "--AaB03x--\r\n";
+
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 1024, 3072, 50);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(contents.getBytes()),
+ _contentType,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ Collection parts = mpis.getParts();
+ assertThat(parts.size(), is(1));
+ assertThat(((MultiPartInputStreamParser.MultiPart)parts.iterator().next()).getSubmittedFileName(), is("Taken on Aug 22 \\ 2012.jpg"));
+ }
+
+ @Test
+ public void testBadlyEncodedMSFilename() throws Exception
+ {
+
+ String contents = "--AaB03x\r\n"+
+ "content-disposition: form-data; name=\"stuff\"; filename=\"" +"c:\\this\\really\\is\\some\\path\\to\\a\\file.txt" + "\"\r\n"+
+ "Content-Type: text/plain\r\n"+
+ "\r\n"+"stuff"+
+ "aaa"+"\r\n" +
+ "--AaB03x--\r\n";
+
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 1024, 3072, 50);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(contents.getBytes()),
+ _contentType,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ Collection parts = mpis.getParts();
+ assertThat(parts.size(), is(1));
+ assertThat(((MultiPartInputStreamParser.MultiPart)parts.iterator().next()).getSubmittedFileName(), is("c:\\this\\really\\is\\some\\path\\to\\a\\file.txt"));
+ }
+
+ @Test
+ public void testCorrectlyEncodedMSFilename() throws Exception
+ {
+ String contents = "--AaB03x\r\n"+
+ "content-disposition: form-data; name=\"stuff\"; filename=\"" +"c:\\\\this\\\\really\\\\is\\\\some\\\\path\\\\to\\\\a\\\\file.txt" + "\"\r\n"+
+ "Content-Type: text/plain\r\n"+
+ "\r\n"+"stuff"+
+ "aaa"+"\r\n" +
+ "--AaB03x--\r\n";
+
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 1024, 3072, 50);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(contents.getBytes()),
+ _contentType,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ Collection parts = mpis.getParts();
+ assertThat(parts.size(), is(1));
+ assertThat(((MultiPartInputStreamParser.MultiPart)parts.iterator().next()).getSubmittedFileName(), is("c:\\this\\really\\is\\some\\path\\to\\a\\file.txt"));
+ }
+
+ public void testMulti ()
+ throws Exception
+ {
+ testMulti(FILENAME);
+ }
+
+ @Test
+ public void testMultiWithSpaceInFilename() throws Exception
+ {
+ testMulti("stuff with spaces.txt");
+ }
+
+
+ @Test
+ public void testWriteFilesIfContentDispositionFilename ()
+ throws Exception
+ {
+ String s = "--AaB03x\r\n"+
+ "content-disposition: form-data; name=\"field1\"; filename=\"frooble.txt\"\r\n"+
+ "\r\n"+
+ "Joe Blow\r\n"+
+ "--AaB03x\r\n"+
+ "content-disposition: form-data; name=\"stuff\"\r\n"+
+ "Content-Type: text/plain\r\n"+
+ "\r\n"+"sss"+
+ "aaa"+"\r\n" +
+ "--AaB03x--\r\n";
+ //all default values for multipartconfig, ie file size threshold 0
+ MultipartConfigElement config = new MultipartConfigElement(_dirname);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(s.getBytes()),
+ _contentType,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ mpis.setWriteFilesWithFilenames(true);
+ Collection parts = mpis.getParts();
+ assertThat(parts.size(), is(2));
+ Part field1 = mpis.getPart("field1"); //has a filename, should be written to a file
+ File f = ((MultiPartInputStreamParser.MultiPart)field1).getFile();
+ assertThat(f,notNullValue()); // longer than 100 bytes, should already be a tmp file
+
+ Part stuff = mpis.getPart("stuff");
+ f = ((MultiPartInputStreamParser.MultiPart)stuff).getFile(); //should only be in memory, no filename
+ assertThat(f, nullValue());
+ }
+
+
+ private void testMulti(String filename) throws IOException, ServletException, InterruptedException
+ {
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 1024, 3072, 50);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(createMultipartRequestString(filename).getBytes()),
+ _contentType,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ Collection parts = mpis.getParts();
+ assertThat(parts.size(), is(2));
+ Part field1 = mpis.getPart("field1"); //field 1 too small to go into tmp file, should be in internal buffer
+ assertThat(field1,notNullValue());
+ assertThat(field1.getName(),is("field1"));
+ InputStream is = field1.getInputStream();
+ ByteArrayOutputStream os = new ByteArrayOutputStream();
+ IO.copy(is, os);
+ assertEquals("Joe Blow", new String(os.toByteArray()));
+ assertEquals(8, field1.getSize());
+
+ assertNotNull(((MultiPartInputStreamParser.MultiPart)field1).getBytes());//in internal buffer
+ field1.write("field1.txt");
+ assertNull(((MultiPartInputStreamParser.MultiPart)field1).getBytes());//no longer in internal buffer
+ File f = new File (_dirname+File.separator+"field1.txt");
+ assertTrue(f.exists());
+ field1.write("another_field1.txt"); //write after having already written
+ File f2 = new File(_dirname+File.separator+"another_field1.txt");
+ assertTrue(f2.exists());
+ assertFalse(f.exists()); //should have been renamed
+ field1.delete(); //file should be deleted
+ assertFalse(f.exists()); //original file was renamed
+ assertFalse(f2.exists()); //2nd written file was explicitly deleted
+
+ MultiPart stuff = (MultiPart)mpis.getPart("stuff");
+ assertThat(stuff.getSubmittedFileName(), is(filename));
+ assertThat(stuff.getContentType(),is("text/plain"));
+ assertThat(stuff.getHeader("Content-Type"),is("text/plain"));
+ assertThat(stuff.getHeaders("content-type").size(),is(1));
+ assertThat(stuff.getHeader("content-disposition"),is("form-data; name=\"stuff\"; filename=\"" + filename + "\""));
+ assertThat(stuff.getHeaderNames().size(),is(2));
+ assertThat(stuff.getSize(),is(51L));
+
+ File tmpfile = ((MultiPartInputStreamParser.MultiPart)stuff).getFile();
+ assertThat(tmpfile,notNullValue()); // longer than 100 bytes, should already be a tmp file
+ assertThat(((MultiPartInputStreamParser.MultiPart)stuff).getBytes(),nullValue()); //not in an internal buffer
+ assertThat(tmpfile.exists(),is(true));
+ assertThat(tmpfile.getName(),is(not("stuff with space.txt")));
+ stuff.write(filename);
+ f = new File(_dirname+File.separator+filename);
+ assertThat(f.exists(),is(true));
+ assertThat(tmpfile.exists(), is(false));
+ try
+ {
+ stuff.getInputStream();
+ }
+ catch (Exception e)
+ {
+ fail("Part.getInputStream() after file rename operation");
+ }
+ f.deleteOnExit(); //clean up after test
+ }
+
+ @Test
+ public void testMultiSameNames ()
+ throws Exception
+ {
+ String sameNames = "--AaB03x\r\n"+
+ "content-disposition: form-data; name=\"stuff\"; filename=\"stuff1.txt\"\r\n"+
+ "Content-Type: text/plain\r\n"+
+ "\r\n"+
+ "00000\r\n"+
+ "--AaB03x\r\n"+
+ "content-disposition: form-data; name=\"stuff\"; filename=\"stuff2.txt\"\r\n"+
+ "Content-Type: text/plain\r\n"+
+ "\r\n"+
+ "110000000000000000000000000000000000000000000000000\r\n"+
+ "--AaB03x--\r\n";
+
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 1024, 3072, 50);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(sameNames.getBytes()),
+ _contentType,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ Collection parts = mpis.getParts();
+ assertEquals(2, parts.size());
+ for (Part p:parts)
+ assertEquals("stuff", p.getName());
+
+ //if they all have the name name, then only retrieve the first one
+ Part p = mpis.getPart("stuff");
+ assertNotNull(p);
+ assertEquals(5, p.getSize());
+ }
+
+ @Test
+ public void testBase64EncodedContent () throws Exception
+ {
+ String contentWithEncodedPart =
+ "--AaB03x\r\n"+
+ "Content-disposition: form-data; name=\"other\"\r\n"+
+ "Content-Type: text/plain\r\n"+
+ "\r\n"+
+ "other" + "\r\n"+
+ "--AaB03x\r\n"+
+ "Content-disposition: form-data; name=\"stuff\"; filename=\"stuff.txt\"\r\n"+
+ "Content-Transfer-Encoding: base64\r\n"+
+ "Content-Type: application/octet-stream\r\n"+
+ "\r\n"+
+ B64Code.encode("hello jetty") + "\r\n"+
+ "--AaB03x\r\n"+
+ "Content-disposition: form-data; name=\"final\"\r\n"+
+ "Content-Type: text/plain\r\n"+
+ "\r\n"+
+ "the end" + "\r\n"+
+ "--AaB03x--\r\n";
+
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 1024, 3072, 50);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(contentWithEncodedPart.getBytes()),
+ _contentType,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ Collection parts = mpis.getParts();
+ assertEquals(3, parts.size());
+
+ Part p1 = mpis.getPart("other");
+ assertNotNull(p1);
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ IO.copy(p1.getInputStream(), baos);
+ assertEquals("other", baos.toString("US-ASCII"));
+
+ Part p2 = mpis.getPart("stuff");
+ assertNotNull(p2);
+ baos = new ByteArrayOutputStream();
+ IO.copy(p2.getInputStream(), baos);
+ assertEquals("hello jetty", baos.toString("US-ASCII"));
+
+ Part p3 = mpis.getPart("final");
+ assertNotNull(p3);
+ baos = new ByteArrayOutputStream();
+ IO.copy(p3.getInputStream(), baos);
+ assertEquals("the end", baos.toString("US-ASCII"));
+ }
+
+ @Test
+ public void testQuotedPrintableEncoding () throws Exception
+ {
+ String contentWithEncodedPart =
+ "--AaB03x\r\n"+
+ "Content-disposition: form-data; name=\"other\"\r\n"+
+ "Content-Type: text/plain\r\n"+
+ "\r\n"+
+ "other" + "\r\n"+
+ "--AaB03x\r\n"+
+ "Content-disposition: form-data; name=\"stuff\"; filename=\"stuff.txt\"\r\n"+
+ "Content-Transfer-Encoding: quoted-printable\r\n"+
+ "Content-Type: text/plain\r\n"+
+ "\r\n"+
+ "truth=3Dbeauty" + "\r\n"+
+ "--AaB03x--\r\n";
+ MultipartConfigElement config = new MultipartConfigElement(_dirname, 1024, 3072, 50);
+ MultiPartInputStreamParser mpis = new MultiPartInputStreamParser(new ByteArrayInputStream(contentWithEncodedPart.getBytes()),
+ _contentType,
+ config,
+ _tmpDir);
+ mpis.setDeleteOnExit(true);
+ Collection parts = mpis.getParts();
+ assertEquals(2, parts.size());
+
+ Part p1 = mpis.getPart("other");
+ assertNotNull(p1);
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ IO.copy(p1.getInputStream(), baos);
+ assertEquals("other", baos.toString("US-ASCII"));
+
+ Part p2 = mpis.getPart("stuff");
+ assertNotNull(p2);
+ baos = new ByteArrayOutputStream();
+ IO.copy(p2.getInputStream(), baos);
+ assertEquals("truth=beauty", baos.toString("US-ASCII"));
+ }
+
+
+
+
+
+ private String createMultipartRequestString(String filename)
+ {
+ int length = filename.length();
+ String name = filename;
+ if (length > 10)
+ name = filename.substring(0,10);
+ StringBuffer filler = new StringBuffer();
+ int i = name.length();
+ while (i < 51)
+ {
+ filler.append("0");
+ i++;
+ }
+
+ return "--AaB03x\r\n"+
+ "content-disposition: form-data; name=\"field1\"; filename=\"frooble.txt\"\r\n"+
+ "\r\n"+
+ "Joe Blow\r\n"+
+ "--AaB03x\r\n"+
+ "content-disposition: form-data; name=\"stuff\"; filename=\"" + filename + "\"\r\n"+
+ "Content-Type: text/plain\r\n"+
+ "\r\n"+name+
+ filler.toString()+"\r\n" +
+ "--AaB03x--\r\n";
+ }
+}