Example usage for org.apache.commons.fileupload FileItemStream getHeaders

List of usage examples for org.apache.commons.fileupload FileItemStream getHeaders

Introduction

In this page you can find the example usage for org.apache.commons.fileupload FileItemStream getHeaders.

Prototype

FileItemHeaders getHeaders();

Source Link

Document

Returns the collection of headers defined locally within this item.

Usage

From source file:org.collectionspace.chain.controller.WebUIRequest.java

private void initRequest(UIUmbrella umbrella, HttpServletRequest request, HttpServletResponse response,
        List<String> p) throws IOException, UIException {
    this.request = request;
    this.response = response;
    boolean isMultipart = ServletFileUpload.isMultipartContent(request);
    if (isMultipart) {
        // Create a new file upload handler
        ServletFileUpload upload = new ServletFileUpload();

        // Parse the request
        FileItemIterator iter;/*from   ww  w. j a v a  2s. c o m*/
        try {
            iter = upload.getItemIterator(request);
            while (iter.hasNext()) {
                FileItemStream item = iter.next();
                String name = item.getFieldName();
                //InputStream stream = item.openStream();
                if (item.isFormField()) {
                    //   System.out.println("Form field " + name + " with value "
                    //    + Streams.asString(stream) + " detected.");
                } else {
                    //   System.out.println("File field " + name + " with file name "
                    //    + item.getName() + " detected.");
                    // Process the input stream
                    contentHeaders = item.getHeaders();
                    uploadName = item.getName();

                    ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
                    if (item != null) {
                        InputStream stream = item.openStream();
                        IOUtils.copy(stream, byteOut);
                        new TeeInputStream(stream, byteOut);

                    }
                    bytebody = byteOut.toByteArray();
                }
            }
        } catch (FileUploadException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    } else {
        body = IOUtils.toString(request.getInputStream(), "UTF-8");
    }

    this.ppath = p.toArray(new String[0]);
    if (!(umbrella instanceof WebUIUmbrella))
        throw new UIException("Bad umbrella");
    this.umbrella = (WebUIUmbrella) umbrella;
    session = calculateSessionId();

}

From source file:org.duracloud.common.rest.RestUtilImpl.java

/**
 * Retrieves the contents of the HTTP Request.
 *
 * @return InputStream from the request/*from w ww .  jav  a 2s .  c o m*/
 */
@Override
public RequestContent getRequestContent(HttpServletRequest request, HttpHeaders headers) throws Exception {
    RequestContent rContent = null;

    // See if the request is a multi-part file upload request
    if (ServletFileUpload.isMultipartContent(request)) {

        // Create a new file upload handler
        ServletFileUpload upload = new ServletFileUpload();

        // Parse the request, use the first available File item
        FileItemIterator iter = upload.getItemIterator(request);
        while (iter.hasNext()) {
            FileItemStream item = iter.next();
            if (!item.isFormField()) {
                rContent = new RequestContent();
                rContent.contentStream = item.openStream();
                rContent.mimeType = item.getContentType();

                FileItemHeaders itemHeaders = item.getHeaders();
                if (itemHeaders != null) {
                    String contentLength = itemHeaders.getHeader("Content-Length");
                    if (contentLength != null) {
                        rContent.size = Long.parseLong(contentLength);
                    }
                }

                break;
            }
        }
    } else {
        // If the content stream was not found as a multipart,
        // try to use the stream from the request directly
        rContent = new RequestContent();
        rContent.contentStream = request.getInputStream();
        if (request.getContentLength() >= 0) {
            rContent.size = request.getContentLength();
        }
    }

    // Attempt to set the mime type and size if not already set
    if (rContent != null) {
        if (rContent.mimeType == null) {
            MediaType mediaType = headers.getMediaType();
            if (mediaType != null) {
                rContent.mimeType = mediaType.toString();
            }
        }

        if (rContent.size == 0) {
            List<String> lengthHeaders = headers.getRequestHeader("Content-Length");
            if (lengthHeaders != null && lengthHeaders.size() > 0) {
                rContent.size = Long.parseLong(lengthHeaders.get(0));
            }
        }
    }

    return rContent;
}

From source file:org.fcrepo.server.rest.RestUtil.java

/**
 * Retrieves the contents of the HTTP Request.
 * @return InputStream from the request/* w w w  .  j  a va  2s .  c o m*/
 */
public static RequestContent getRequestContent(HttpServletRequest request, HttpHeaders headers)
        throws Exception {
    RequestContent rContent = null;

    // See if the request is a multi-part file upload request
    if (ServletFileUpload.isMultipartContent(request)) {

        logger.debug("processing multipart content...");
        // Create a new file upload handler
        ServletFileUpload upload = new ServletFileUpload();

        // Parse the request, use the first available File item
        FileItemIterator iter = upload.getItemIterator(request);
        while (iter.hasNext()) {
            FileItemStream item = iter.next();
            if (!item.isFormField()) {
                rContent = new RequestContent();
                rContent.contentStream = item.openStream();
                rContent.mimeType = item.getContentType();

                FileItemHeaders itemHeaders = item.getHeaders();
                if (itemHeaders != null) {
                    String contentLength = itemHeaders.getHeader("Content-Length");
                    if (contentLength != null) {
                        rContent.size = Long.parseLong(contentLength);
                    }
                }

                break;
            } else {
                logger.trace("ignoring form field \"{}\" \"{}\"", item.getFieldName(), item.getName());
            }
        }
    } else {
        // If the content stream was not been found as a multipart,
        // try to use the stream from the request directly
        if (rContent == null) {
            String contentLength = request.getHeader("Content-Length");
            long size = 0;
            if (contentLength != null) {
                size = Long.parseLong(contentLength);
            } else
                size = request.getContentLength();
            if (size > 0) {
                rContent = new RequestContent();
                rContent.contentStream = request.getInputStream();
                rContent.size = size;
            } else {
                String transferEncoding = request.getHeader("Transfer-Encoding");
                if (transferEncoding != null && transferEncoding.contains("chunked")) {
                    BufferedInputStream bis = new BufferedInputStream(request.getInputStream());
                    bis.mark(2);
                    if (bis.read() > 0) {
                        bis.reset();
                        rContent = new RequestContent();
                        rContent.contentStream = bis;
                    }
                } else {
                    logger.warn(
                            "Expected chunked data not found- " + "Transfer-Encoding : {}, Content-Length: {}",
                            transferEncoding, size);
                }
            }
        }
    }

    // Attempt to set the mime type and size if not already set
    if (rContent != null) {
        if (rContent.mimeType == null) {
            MediaType mediaType = headers.getMediaType();
            if (mediaType != null) {
                rContent.mimeType = mediaType.toString();
            }
        }

        if (rContent.size == 0) {
            List<String> lengthHeaders = headers.getRequestHeader("Content-Length");
            if (lengthHeaders != null && lengthHeaders.size() > 0) {
                rContent.size = Long.parseLong(lengthHeaders.get(0));
            }
        }
    }

    return rContent;
}

From source file:org.jahia.ajax.gwt.content.server.GWTFileManagerUploadServlet.java

@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {

    FileItemFactory factory = new DiskFileItemFactory();
    ServletFileUpload upload = new ServletFileUpload(factory);
    SettingsBean settingsBean = SettingsBean.getInstance();
    final long fileSizeLimit = settingsBean.getJahiaFileUploadMaxSize();
    upload.setHeaderEncoding("UTF-8");
    Map<String, FileItem> uploads = new HashMap<String, FileItem>();
    String location = null;// w  w  w.j av  a 2 s. co m
    String type = null;
    boolean unzip = false;
    response.setContentType("text/plain; charset=" + settingsBean.getCharacterEncoding());
    final PrintWriter printWriter = response.getWriter();
    try {
        FileItemIterator itemIterator = upload.getItemIterator(request);
        FileSizeLimitExceededException sizeLimitExceededException = null;
        while (itemIterator.hasNext()) {
            final FileItemStream item = itemIterator.next();
            if (sizeLimitExceededException != null) {
                continue;
            }
            FileItem fileItem = factory.createItem(item.getFieldName(), item.getContentType(),
                    item.isFormField(), item.getName());
            long contentLength = getContentLength(item.getHeaders());

            // If we have a content length in the header we can use it
            if (fileSizeLimit > 0 && contentLength != -1L && contentLength > fileSizeLimit) {
                throw new FileSizeLimitExceededException("The field " + item.getFieldName()
                        + " exceeds its maximum permitted size of " + fileSizeLimit + " bytes.", contentLength,
                        fileSizeLimit);
            }
            InputStream itemStream = item.openStream();

            InputStream limitedInputStream = null;
            try {
                limitedInputStream = fileSizeLimit > 0 ? new LimitedInputStream(itemStream, fileSizeLimit) {

                    @Override
                    protected void raiseError(long pSizeMax, long pCount) throws IOException {
                        throw new FileUploadIOException(new FileSizeLimitExceededException(
                                "The field " + item.getFieldName() + " exceeds its maximum permitted size of "
                                        + fileSizeLimit + " bytes.",
                                pCount, pSizeMax));
                    }
                } : itemStream;

                Streams.copy(limitedInputStream, fileItem.getOutputStream(), true);
            } catch (FileUploadIOException e) {
                if (e.getCause() instanceof FileSizeLimitExceededException) {
                    if (sizeLimitExceededException == null) {
                        sizeLimitExceededException = (FileSizeLimitExceededException) e.getCause();
                    }
                } else {
                    throw e;
                }
            } finally {
                IOUtils.closeQuietly(limitedInputStream);
            }

            if ("unzip".equals(fileItem.getFieldName())) {
                unzip = true;
            } else if ("uploadLocation".equals(fileItem.getFieldName())) {
                location = fileItem.getString("UTF-8");
            } else if ("asyncupload".equals(fileItem.getFieldName())) {
                String name = fileItem.getName();
                if (name.trim().length() > 0) {
                    uploads.put(extractFileName(name, uploads), fileItem);
                }
                type = "async";
            } else if (!fileItem.isFormField() && fileItem.getFieldName().startsWith("uploadedFile")) {
                String name = fileItem.getName();
                if (name.trim().length() > 0) {
                    uploads.put(extractFileName(name, uploads), fileItem);
                }
                type = "sync";
            }
        }
        if (sizeLimitExceededException != null) {
            throw sizeLimitExceededException;
        }
    } catch (FileUploadBase.FileSizeLimitExceededException e) {
        printWriter.write("UPLOAD-SIZE-ISSUE: " + getSizeLimitErrorMessage(fileSizeLimit, e, request) + "\n");
        return;
    } catch (FileUploadIOException e) {
        if (e.getCause() != null && (e.getCause() instanceof FileSizeLimitExceededException)) {
            printWriter.write("UPLOAD-SIZE-ISSUE: " + getSizeLimitErrorMessage(fileSizeLimit,
                    (FileSizeLimitExceededException) e.getCause(), request) + "\n");
        } else {
            logger.error("UPLOAD-ISSUE", e);
            printWriter.write("UPLOAD-ISSUE: " + e.getLocalizedMessage() + "\n");
        }
        return;
    } catch (FileUploadException e) {
        logger.error("UPLOAD-ISSUE", e);
        printWriter.write("UPLOAD-ISSUE: " + e.getLocalizedMessage() + "\n");
        return;
    }

    if (type == null || type.equals("sync")) {
        response.setContentType("text/plain");

        final JahiaUser user = (JahiaUser) request.getSession().getAttribute(Constants.SESSION_USER);

        final List<String> pathsToUnzip = new ArrayList<String>();
        for (String fileName : uploads.keySet()) {
            final FileItem fileItem = uploads.get(fileName);
            try {
                StringBuilder name = new StringBuilder(fileName);
                final int saveResult = saveToJcr(user, fileItem, location, name);
                switch (saveResult) {
                case OK:
                    if (unzip && fileName.toLowerCase().endsWith(".zip")) {
                        pathsToUnzip.add(
                                new StringBuilder(location).append("/").append(name.toString()).toString());
                    }
                    printWriter.write("OK: " + UriUtils.encode(name.toString()) + "\n");
                    break;
                case EXISTS:
                    storeUploadedFile(request.getSession().getId(), fileItem);
                    printWriter.write("EXISTS: " + UriUtils.encode(fileItem.getFieldName()) + " "
                            + UriUtils.encode(fileItem.getName()) + " " + UriUtils.encode(fileName) + "\n");
                    break;
                case READONLY:
                    printWriter.write("READONLY: " + UriUtils.encode(fileItem.getFieldName()) + "\n");
                    break;
                default:
                    printWriter.write("UPLOAD-FAILED: " + UriUtils.encode(fileItem.getFieldName()) + "\n");
                    break;
                }
            } catch (IOException e) {
                logger.error("Upload failed for file \n", e);
            } finally {
                fileItem.delete();
            }
        }

        // direct blocking unzip
        if (unzip && pathsToUnzip.size() > 0) {
            try {
                ZipHelper zip = ZipHelper.getInstance();
                //todo : in which workspace do we upload ?
                zip.unzip(pathsToUnzip, true, JCRSessionFactory.getInstance().getCurrentUserSession(),
                        (Locale) request.getSession().getAttribute(Constants.SESSION_UI_LOCALE));
            } catch (RepositoryException e) {
                logger.error("Auto-unzipping failed", e);
            } catch (GWTJahiaServiceException e) {
                logger.error("Auto-unzipping failed", e);
            }
        }
    } else {
        response.setContentType("text/html");
        for (FileItem fileItem : uploads.values()) {
            storeUploadedFile(request.getSession().getId(), fileItem);
            printWriter.write("<html><body>");
            printWriter.write("<div id=\"uploaded\" key=\"" + fileItem.getName() + "\" name=\""
                    + fileItem.getName() + "\"></div>\n");
            printWriter.write("</body></html>");
        }
    }
}

From source file:org.jahia.tools.files.FileUpload.java

/**
 * Init the MultiPartReq object if it's actually null
 *
 * @exception IOException//www  . jav a  2 s  . co m
 */
protected void init() throws IOException {

    params = new HashMap<String, List<String>>();
    paramsContentType = new HashMap<String, String>();
    files = new HashMap<String, DiskFileItem>();
    filesByFieldName = new HashMap<String, DiskFileItem>();

    parseQueryString();

    if (checkSavePath(savePath)) {
        try {
            final ServletFileUpload upload = new ServletFileUpload();
            FileItemIterator iter = upload.getItemIterator(req);
            DiskFileItemFactory factory = null;
            while (iter.hasNext()) {
                FileItemStream item = iter.next();
                InputStream stream = item.openStream();
                if (item.isFormField()) {
                    final String name = item.getFieldName();
                    final List<String> v;
                    if (params.containsKey(name)) {
                        v = params.get(name);
                    } else {
                        v = new ArrayList<String>();
                        params.put(name, v);
                    }
                    v.add(Streams.asString(stream, encoding));
                    paramsContentType.put(name, item.getContentType());
                } else {
                    if (factory == null) {
                        factory = new DiskFileItemFactory();
                        factory.setSizeThreshold(1);
                        factory.setRepository(new File(savePath));
                    }
                    DiskFileItem fileItem = (DiskFileItem) factory.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 " + FileUploadBase.MULTIPART_FORM_DATA
                                + " request failed. " + e.getMessage(), e);
                    }
                    final FileItemHeaders fih = item.getHeaders();
                    fileItem.setHeaders(fih);
                    if (fileItem.getSize() > 0) {
                        files.put(fileItem.getStoreLocation().getName(), fileItem);
                        filesByFieldName.put(fileItem.getFieldName(), fileItem);
                    }
                }
            }
        } catch (FileUploadException ioe) {
            logger.error("Error while initializing FileUpload class:", ioe);
            throw new IOException(ioe.getMessage());
        }
    } else {
        logger.error("FileUpload::init storage path does not exists or can write");
        throw new IOException("FileUpload::init storage path does not exists or cannot write");
    }
}

From source file:org.jasig.portal.utils.web.FileUploadLogger.java

public static void logFileUploadInfo(HttpServletRequest request) {
    final boolean multipartContent = ServletFileUpload.isMultipartContent(request);
    System.out.println("multipartContent=" + multipartContent);
    if (!multipartContent) {
        return;/*from   ww  w . j a v  a 2s . co  m*/
    }

    DiskFileItemFactory factory = new DiskFileItemFactory();
    final ServletFileUpload servletFileUpload = new ServletFileUpload(factory);

    try {
        final FileItemIterator itemIterator = servletFileUpload.getItemIterator(request);
        while (itemIterator.hasNext()) {
            final FileItemStream next = itemIterator.next();
            System.out.println("FileItemStream: " + next.getName());
            System.out.println("\t" + next.getContentType());
            System.out.println("\t" + next.getFieldName());

            final FileItemHeaders headers = next.getHeaders();
            if (headers != null) {
                System.out.println(
                        "\t" + Arrays.toString(Iterators.toArray(headers.getHeaderNames(), String.class)));
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

From source file:org.synchronoss.cloud.nio.multipart.FunctionalTest.java

static void assertEquals(final BlockingIOAdapter.PartItem partItem, final FileItemStream fileItemStream)
        throws IOException {

    if (partItem instanceof BlockingIOAdapter.FormParameter) {
        BlockingIOAdapter.FormParameter formParameter = (BlockingIOAdapter.FormParameter) partItem;
        assertHeadersAreEqual(fileItemStream.getHeaders(), formParameter.getHeaders());
        Assert.assertEquals(formParameter.getFieldValue(), IOUtils.toString(fileItemStream.openStream()));
    } else if (partItem instanceof BlockingIOAdapter.Attachment) {
        BlockingIOAdapter.Attachment attachment = (BlockingIOAdapter.Attachment) partItem;
        assertHeadersAreEqual(fileItemStream.getHeaders(), attachment.getHeaders());
        assertInputStreamsAreEqual(attachment.getPartBody(), fileItemStream.openStream());
    } else {//from   w  w w .  j a  va2 s  . co m
        fail("Invalid part item type " + partItem.getClass());
    }

}

From source file:org.synchronoss.cloud.nio.multipart.FunctionalTest.java

NioMultipartParserListener nioMultipartParserListenerVerifier(final FileItemIterator fileItemIterator,
        final AtomicBoolean finished) {

    return new NioMultipartParserListener() {

        AtomicInteger partIndex = new AtomicInteger(0);

        @Override//  w  ww.j  ava 2s . co  m
        public void onPartFinished(StreamStorage partBodyStreamStorage,
                Map<String, List<String>> headersFromPart) {
            log.info("<<<<< On part complete [" + (partIndex.addAndGet(1)) + "] >>>>>>");
            assertFileItemIteratorHasNext(true);
            final FileItemStream fileItemStream = fileItemIteratorNext();
            assertHeadersAreEqual(fileItemStream.getHeaders(), headersFromPart);
            assertInputStreamsAreEqual(fileItemStreamInputStream(fileItemStream),
                    partBodyStreamStorage.getInputStream());
        }

        @Override
        public void onFormFieldPartFinished(String fieldName, String fieldValue,
                Map<String, List<String>> headersFromPart) {
            log.info("<<<<< On form field complete [" + (partIndex.addAndGet(1)) + "] >>>>>>");
            assertFileItemIteratorHasNext(true);
            final FileItemStream fileItemStream = fileItemIteratorNext();
            assertTrue(fileItemStream.isFormField());
            Assert.assertEquals(fieldName, fileItemStream.getFieldName());
            try {
                Assert.assertEquals(fieldValue, IOUtils.toString(fileItemStream.openStream()));
            } catch (Exception e) {
                throw new IllegalStateException("Unable to assert field value", e);
            }
        }

        @Override
        public void onNestedPartStarted(Map<String, List<String>> headersFromParentPart) {
            log.info("<<<<< On form field complete [" + (partIndex) + "] >>>>>>");
        }

        @Override
        public void onAllPartsFinished() {
            log.info("<<<<< On all parts read: Number of parts [" + partIndex.get() + "] >>>>>>");
            assertFileItemIteratorHasNext(false);
            finished.set(true);
        }

        @Override
        public void onNestedPartFinished() {
            log.info("<<<<< On form field complete [" + (partIndex) + "] >>>>>>");
        }

        @Override
        public void onError(String message, Throwable cause) {
            log.info("<<<<< On error. Part " + partIndex.get() + "] >>>>>>");
            finished.set(true);
            log.error(message, cause);
            fail("Got an error from the parser");
        }

        InputStream fileItemStreamInputStream(final FileItemStream fileItemStream) {
            try {
                return fileItemStream.openStream();
            } catch (Exception e) {
                throw new IllegalStateException("Unable to open the file item inputstream", e);
            }
        }

        void assertFileItemIteratorHasNext(boolean hasNext) {
            try {
                assertTrue("File iterator has next is not " + hasNext, hasNext == fileItemIterator.hasNext());
            } catch (Exception e) {
                throw new IllegalStateException("Unable to verify if the FileItemIterator has a next", e);
            }
        }

        FileItemStream fileItemIteratorNext() {
            try {
                return fileItemIterator.next();
            } catch (Exception e) {
                throw new IllegalStateException("Unable to retrieve the next FileItemStream", e);
            }
        }

    };
}

From source file:org.synchronoss.cloud.nio.multipart.FunctionalTest.java

void dumpFileIterator(final FileItemIterator fileItemIterator) {

    int partIndex = 0;

    try {/*from  w  w  w. java 2s  .c  o m*/
        log.info("-- COMMONS FILE UPLOAD --");
        while (fileItemIterator.hasNext()) {
            log.info("-- Part " + partIndex++);
            FileItemStream fileItemStream = fileItemIterator.next();

            FileItemHeaders fileItemHeaders = fileItemStream.getHeaders();
            Iterator<String> headerNames = fileItemHeaders.getHeaderNames();
            while (headerNames.hasNext()) {
                String headerName = headerNames.next();
                log.info("Header: " + headerName + ": "
                        + Joiner.on(',').join(fileItemHeaders.getHeaders(headerName)));
            }
            log.info("Body:\n" + IOUtils.toString(fileItemStream.openStream()));
        }
        log.info("-- ------------------- --");
    } catch (Exception e) {
        log.error("Error dumping the FileItemIterator", e);
    }

}

From source file:zutil.jee.upload.AjaxFileUpload.java

@SuppressWarnings("unchecked")
protected void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {

    FileUploadListener listener = new FileUploadListener();
    try {// w w  w.jav  a2 s  .com
        // Initiate list and HashMap that will contain the data
        HashMap<String, String> fields = new HashMap<String, String>();
        ArrayList<FileItem> files = new ArrayList<FileItem>();

        // Add the listener to the session
        HttpSession session = request.getSession();
        LinkedList<FileUploadListener> list = (LinkedList<FileUploadListener>) session
                .getAttribute(SESSION_FILEUPLOAD_LISTENER);
        if (list == null) {
            list = new LinkedList<FileUploadListener>();
            session.setAttribute(SESSION_FILEUPLOAD_LISTENER, list);
        }
        list.add(listener);

        // Create a factory for disk-based file items
        DiskFileItemFactory factory = new DiskFileItemFactory();
        if (TEMPFILE_PATH != null)
            factory.setRepository(TEMPFILE_PATH);
        // Create a new file upload handler
        ServletFileUpload upload = new ServletFileUpload(factory);
        upload.setProgressListener(listener);
        // Set overall request size constraint
        //upload.setSizeMax(yourMaxRequestSize);

        // Parse the request
        FileItemIterator it = upload.getItemIterator(request);
        while (it.hasNext()) {
            FileItemStream item = it.next();
            // Is the file type allowed?
            if (!item.isFormField()
                    && !ALLOWED_EXTENSIONS.contains(FileUtil.getFileExtension(item.getName()).toLowerCase())) {
                String msg = "Filetype '" + FileUtil.getFileExtension(item.getName()) + "' is not allowed!";
                logger.warning(msg);
                listener.setStatus(Status.Error);
                listener.setFileName(item.getName());
                listener.setMessage(msg);
                return;
            }
            listener.setFileName(item.getName());
            FileItem fileItem = factory.createItem(item.getFieldName(), item.getContentType(),
                    item.isFormField(), item.getName());
            // Read the file data
            Streams.copy(item.openStream(), fileItem.getOutputStream(), true);
            if (fileItem instanceof FileItemHeadersSupport) {
                final FileItemHeaders fih = item.getHeaders();
                ((FileItemHeadersSupport) fileItem).setHeaders(fih);
            }

            //Handle the item
            if (fileItem.isFormField()) {
                fields.put(fileItem.getFieldName(), fileItem.getString());
            } else {
                files.add(fileItem);
                logger.info("Recieved file: " + fileItem.getName() + " ("
                        + StringUtil.formatByteSizeToString(fileItem.getSize()) + ")");
            }
        }
        // Process the upload
        listener.setStatus(Status.Processing);
        doUpload(request, response, fields, files);
        // Done
        listener.setStatus(Status.Done);
    } catch (Exception e) {
        logger.log(Level.SEVERE, null, e);
        listener.setStatus(Status.Error);
        listener.setFileName("");
        listener.setMessage(e.getMessage());
    }
}