protected FileItem createItem(Map headers,
    boolean isFormField) throws FileUploadException 
{
        return getFileItemFactory().createItem(getFieldName(headers),
                getHeader(headers, CONTENT_TYPE),
                isFormField,
                getFileName(headers));
}

Creates a new FileItem instance.

 protected byte[] getBoundary(String contentType) 
{
        ParameterParser parser = new ParameterParser();
        parser.setLowerCaseNames(true);
        // Parameter parser can handle null input
        Map params = parser.parse(contentType, ';");
        String boundaryStr = (String) params.get("boundary");
        if (boundaryStr == null) {
            return null;
        }
        byte[] boundary;
        try {
            boundary = boundaryStr.getBytes("ISO-8859-1");
        } catch (UnsupportedEncodingException e) {
            boundary = boundaryStr.getBytes();
        }
        return boundary;
}

Retrieves the boundary from the Content-type header.

 protected String getFieldName(Map headers) 
{
        String fieldName = null;
        String cd = getHeader(headers, CONTENT_DISPOSITION);
        if (cd != null && cd.toLowerCase().startsWith(FORM_DATA)) {
            ParameterParser parser = new ParameterParser();
            parser.setLowerCaseNames(true);
            // Parameter parser can handle null input
            Map params = parser.parse(cd, ';");
            fieldName = (String) params.get("name");
            if (fieldName != null) {
                fieldName = fieldName.trim();
            }
        }
        return fieldName;
}

Retrieves the field name from the Content-disposition header.

 abstract public FileItemFactory getFileItemFactory()
Returns the factory class used when creating file items.

 protected String getFileName(Map headers) 
{
        String fileName = null;
        String cd = getHeader(headers, CONTENT_DISPOSITION);
        if (cd != null) {
            String cdl = cd.toLowerCase();
            if (cdl.startsWith(FORM_DATA) || cdl.startsWith(ATTACHMENT)) {
                ParameterParser parser = new ParameterParser();
                parser.setLowerCaseNames(true);
                // Parameter parser can handle null input
                Map params = parser.parse(cd, ';");
                if (params.containsKey("filename")) {
                    fileName = (String) params.get("filename");
                    if (fileName != null) {
                        fileName = fileName.trim();
                    } else {
                        // Even if there is no value, the parameter is present,
                        // so we return an empty file name rather than no file
                        // name.
                        fileName = "";
                    }
                }
            }
        }
        return fileName;
}

Retrieves the file name from the Content-disposition header.

 public long getFileSizeMax() 
{
        return fileSizeMax;
}

Returns the maximum allowed size of a single uploaded file, as opposed to #getSizeMax() .

 protected final String getHeader(Map headers,
    String name) 
{
        return (String) headers.get(name.toLowerCase());
}

Returns the header with the specified name from the supplied map. The header lookup is case-insensitive.

 public String getHeaderEncoding() 
{
        return headerEncoding;
}

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.

 public FileItemIterator getItemIterator(RequestContext ctx) throws IOException, FileUploadException 
{
        return new FileItemIteratorImpl(ctx);
}

Processes an RFC 1867 compliant multipart/form-data stream.

 public ProgressListener getProgressListener() 
{
        return listener;
}

Returns the progress listener.

 public long getSizeMax() 
{
    // ----------------------------------------------------- Property accessors
        return sizeMax;
}

Returns the maximum allowed size of a complete request, as opposed to #getFileSizeMax() .

 public static final boolean isMultipartContent(RequestContext ctx) 
{
        String contentType = ctx.getContentType();
        if (contentType == null) {
            return false;
        }
        if (contentType.toLowerCase().startsWith(MULTIPART)) {
            return true;
        }
        return false;
}

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.

 public static boolean isMultipartContent(HttpServletRequest req) 
{
        return ServletFileUpload.isMultipartContent(req);
}

Utility method that determines whether the request contains multipart content.

 protected Map parseHeaders(String headerPart) 
{
        final int len = headerPart.length();
        Map headers = new HashMap();
        int start = 0;
        for (;;) {
            int end = parseEndOfLine(headerPart, start);
            if (start == end) {
                break;
            }
            String header = headerPart.substring(start, end);
            start = end + 2;
            while (start <  len) {
                int nonWs = start;
                while (nonWs <  len) {
                    char c = headerPart.charAt(nonWs);
                    if (c != ' "  &&  c != '\t") {
                        break;
                    }
                    ++nonWs;
                }
                if (nonWs == start) {
                    break;
                }
                // Continuation line found
                end = parseEndOfLine(headerPart, nonWs);
                header += " " + headerPart.substring(nonWs, end);
                start = end + 2;
            }
            parseHeaderLine(headers, header);
        }
        return headers;
}

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.

 public List parseRequest(HttpServletRequest req) throws FileUploadException 
{
        return parseRequest(new ServletRequestContext(req));
}

Processes an RFC 1867 compliant multipart/form-data stream.

 public List parseRequest(RequestContext ctx) throws FileUploadException 
{
        try {
            FileItemIterator iter = getItemIterator(ctx);
            List items = new ArrayList();
            FileItemFactory fac = getFileItemFactory();
            if (fac == null) {
                throw new NullPointerException(
                    "No FileItemFactory has been set.");
            }
            while (iter.hasNext()) {
                FileItemStream item = iter.next();
                FileItem fileItem = fac.createItem(item.getFieldName(),
                        item.getContentType(), item.isFormField(),
                        item.getName());
                try {
                    Streams.copy(item.openStream(), fileItem.getOutputStream(),
                            true);
                } catch (FileUploadIOException e) {
                    throw (FileUploadException) e.getCause();
                } catch (IOException e) {
                    throw new IOFileUploadException(
                            "Processing of " + MULTIPART_FORM_DATA
                            + " request failed. " + e.getMessage(), e);
                }
                items.add(fileItem);
            }
            return items;
        } catch (FileUploadIOException e) {
            throw (FileUploadException) e.getCause();
        } catch (IOException e) {
            throw new FileUploadException(e.getMessage(), e);
        }
}

Processes an RFC 1867 compliant multipart/form-data stream.

 abstract public  void setFileItemFactory(FileItemFactory factory)
Sets the factory class to use when creating file items.

 public  void setFileSizeMax(long fileSizeMax) 
{
        this.fileSizeMax = fileSizeMax;
}

Sets the maximum allowed size of a single uploaded file, as opposed to #getSizeMax() .

 public  void setHeaderEncoding(String encoding) 
{
        headerEncoding = encoding;
}

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.

 public  void setProgressListener(ProgressListener pListener) 
{
        listener = pListener;
}

Sets the progress listener.

 public  void setSizeMax(long sizeMax) 
{
        this.sizeMax = sizeMax;
}

Sets the maximum allowed size of a complete request, as opposed to #setFileSizeMax(long) .