Synnefo » Pithos

/*

 * Copyright 2008, 2009, 2010 Electronic Business Systems Ltd.

 *

 * This file is part of GSS.

 *

 * GSS is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation, either version 3 of the License, or

 * (at your option) any later version.

 *

 * GSS is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with GSS.  If not, see <http://www.gnu.org/licenses/>.

 */

package gr.ebs.gss.server.rest;

import static gr.ebs.gss.server.configuration.GSSConfigurationFactory.getConfiguration;

import gr.ebs.gss.common.exceptions.DuplicateNameException;

import gr.ebs.gss.common.exceptions.GSSIOException;

import gr.ebs.gss.common.exceptions.InsufficientPermissionsException;

import gr.ebs.gss.common.exceptions.ObjectNotFoundException;

import gr.ebs.gss.common.exceptions.QuotaExceededException;

import gr.ebs.gss.common.exceptions.RpcException;

import gr.ebs.gss.server.Login;

import gr.ebs.gss.server.domain.FileBody;

import gr.ebs.gss.server.domain.FileHeader;

import gr.ebs.gss.server.domain.FileUploadStatus;

import gr.ebs.gss.server.domain.Folder;

import gr.ebs.gss.server.domain.Group;

import gr.ebs.gss.server.domain.Permission;

import gr.ebs.gss.server.domain.User;

import gr.ebs.gss.server.ejb.ExternalAPI;

import gr.ebs.gss.server.ejb.TransactionHelper;

import java.io.BufferedReader;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.io.PrintWriter;

import java.io.UnsupportedEncodingException;

import java.net.URI;

import java.net.URISyntaxException;

import java.net.URLDecoder;

import java.net.URLEncoder;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Date;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import java.util.StringTokenizer;

import java.util.concurrent.Callable;

import javax.servlet.ServletContext;

import javax.servlet.ServletException;

import javax.servlet.ServletOutputStream;

import javax.servlet.http.Cookie;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.commons.codec.binary.Base64;

import org.apache.commons.fileupload.FileItemIterator;

import org.apache.commons.fileupload.FileItemStream;

import org.apache.commons.fileupload.FileUploadException;

import org.apache.commons.fileupload.ProgressListener;

import org.apache.commons.fileupload.servlet.ServletFileUpload;

import org.apache.commons.fileupload.util.Streams;

import org.apache.commons.httpclient.util.DateParseException;

import org.apache.commons.httpclient.util.DateUtil;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.json.JSONArray;

import org.json.JSONException;

import org.json.JSONObject;

/**

 * A class that handles operations on the 'files' namespace.

 *

 * @author past

 */

public class FilesHandler extends RequestHandler {

        /**

         * The request parameter name for fetching a different version.

         */

        private static final String VERSION_PARAM = "version";

        /**

         * The request attribute containing the owner of the destination URI

         * in a copy or move request.

         */

        private static final String DESTINATION_OWNER_ATTRIBUTE = "destOwner";

        private static final int TRACK_PROGRESS_PERCENT = 5;

        /**

         * The form parameter name that contains the signature in a browser POST upload.

         */

        private static final String AUTHORIZATION_PARAMETER = "Authorization";

        /**

         * The form parameter name that contains the date in a browser POST upload.

         */

        private static final String DATE_PARAMETER = "Date";

        /**

         * The request parameter name for making an upload progress request.

         */

        private static final String PROGRESS_PARAMETER = "progress";

        /**

         * The request parameter name for restoring a previous version of a file.

         */

        private static final String RESTORE_VERSION_PARAMETER = "restoreVersion";

        /**

         * The logger.

         */

        private static Log logger = LogFactory.getLog(FilesHandler.class);

        /**

         * The servlet context provided by the call site.

         */

        private ServletContext context;

        /**

         * The style sheet for displaying the directory listings.

         */

        private static final String GSS_CSS = "H1 {font-family:Tahoma,Arial,sans-serif;color:white;background-color:#525D76;font-size:22px;} " + "H2 {font-family:Tahoma,Arial,sans-serif;color:white;background-color:#525D76;font-size:16px;} " + "H3 {font-family:Tahoma,Arial,sans-serif;color:white;background-color:#525D76;font-size:14px;} " + "BODY {font-family:Tahoma,Arial,sans-serif;color:black;background-color:white;} " + "B {font-family:Tahoma,Arial,sans-serif;color:white;background-color:#525D76;} " + "P {font-family:Tahoma,Arial,sans-serif;background:white;color:black;font-size:12px;}" + "A {color : black;}" + "A.name {color : black;}" + "HR {color : #525D76;}";

        /**

         * @param servletContext

         */

        public FilesHandler(ServletContext servletContext) {

                context = servletContext;

        }

        private void updateAccounting(final User user, final Date date, final long bandwidthDiff) {

                try {

                        new TransactionHelper<Void>().tryExecute(new Callable<Void>() {

                                @Override

                                public Void call() throws Exception {

                                        getService().updateAccounting(user, date, bandwidthDiff);

                                        return null;

                                }

                        });

                } catch (RuntimeException e) {

                        throw e;

                } catch (Exception e) {

                        // updateAccounting() doesn't throw any checked exceptions

                        assert false;

                }

        }

        /**

     * Serve the specified resource, optionally including the data content.

     *

     * @param req The servlet request we are processing

     * @param resp The servlet response we are creating

     * @param content Should the content be included?

     *

     * @exception IOException if an input/output error occurs

     * @exception ServletException if a servlet-specified error occurs

     * @throws RpcException

     * @throws InsufficientPermissionsException

     * @throws ObjectNotFoundException

     */

        @Override

        protected void serveResource(HttpServletRequest req, HttpServletResponse resp, boolean content)

                    throws IOException, ServletException {

                boolean authDeferred = getAuthDeferred(req);

        String path = getInnerPath(req, PATH_FILES);

                if (path.equals(""))

                        path = "/";

                try {

                        path = URLDecoder.decode(path, "UTF-8");

                } catch (IllegalArgumentException e) {

                resp.sendError(HttpServletResponse.SC_BAD_REQUEST, e.getMessage());

                        return;

                }

            String progress = req.getParameter(PROGRESS_PARAMETER);

            if (logger.isDebugEnabled())

                        if (content)

                            logger.debug("Serving resource '" +        path + "' headers and data");

                    else

                            logger.debug("Serving resource '" +        path + "' headers only");

            User user = getUser(req);

            User owner = getOwner(req);

        boolean exists = true;

        Object resource = null;

        FileHeader file = null;

        Folder folder = null;

        try {

                resource = getService().getResourceAtPath(owner.getId(), path, false);

        } catch (ObjectNotFoundException e) {

            exists = false;

        } catch (RpcException e) {

                resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, path);

                        return;

                }

            if (!exists && authDeferred) {

                    // We do not want to leak information if the request

                    // was not authenticated.

                    resp.sendError(HttpServletResponse.SC_FORBIDDEN);

                    return;

            }

            if (resource instanceof Folder)

                    folder = (Folder) resource;

            else

                    file = (FileHeader) resource;        // Note that file will be null, if (!exists).

            // Now it's time to perform the deferred authentication check.

                // Since regular signature checking was already performed,

                // we need to check the read-all flag or the signature-in-parameters.

                if (authDeferred) {

                        if (file != null && !file.isReadForAll() && content) {

                                // Check for GET with the signature in the request parameters.

                                String auth = req.getParameter(AUTHORIZATION_PARAMETER);

                                String dateParam = req.getParameter(DATE_PARAMETER);

                                if (auth == null || dateParam == null) {

                                        // Check for a valid authentication cookie.

                                        if (req.getCookies() != null) {

                                                boolean found = false;

                                                for (Cookie cookie : req.getCookies())

                                                        if (Login.AUTH_COOKIE.equals(cookie.getName())) {

                                                                String cookieauth = cookie.getValue();

                                                                int sepIndex = cookieauth.indexOf(Login.COOKIE_SEPARATOR);

                                                                if (sepIndex == -1) {

                                                                        handleAuthFailure(req, resp);

                                                                        return;

                                                                }

                                                                String username = URLDecoder.decode(cookieauth.substring(0, sepIndex), "US-ASCII");

                                                                user = null;

                                                                try {

                                                                        user = getService().findUser(username);

                                                                } catch (RpcException e) {

                                                                resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, path);

                                                                        return;

                                                                }

                                                                if (user == null) {

                                                                    resp.sendError(HttpServletResponse.SC_FORBIDDEN);

                                                                    return;

                                                            }

                                                                req.setAttribute(USER_ATTRIBUTE, user);

                                                                String token = cookieauth.substring(sepIndex + 1);

                                                                if (user.getAuthToken() == null) {

                                                                        resp.sendError(HttpServletResponse.SC_FORBIDDEN);

                                                                        return;

                                                                }

                                                                if (!Arrays.equals(user.getAuthToken(), Base64.decodeBase64(token))) {

                                                                        resp.sendError(HttpServletResponse.SC_FORBIDDEN);

                                                                        return;

                                                                }

                                                                found = true;

                                                                break;

                                                        }

                                                if (!found) {

                                                        handleAuthFailure(req, resp);

                                                        return;

                                                }

                                        } else {

                                                handleAuthFailure(req, resp);

                                                return;

                                        }

                                } else {

                                    long timestamp;

                                        try {

                                                timestamp = DateUtil.parseDate(dateParam).getTime();

                                        } catch (DateParseException e) {

                                            resp.sendError(HttpServletResponse.SC_FORBIDDEN, e.getMessage());

                                            return;

                                        }

                                    if (!isTimeValid(timestamp)) {

                                            resp.sendError(HttpServletResponse.SC_FORBIDDEN);

                                            return;

                                    }

                                        // Fetch the Authorization parameter and find the user specified in it.

                                        String[] authParts = auth.split(" ");

                                        if (authParts.length != 2) {

                                            resp.sendError(HttpServletResponse.SC_FORBIDDEN);

                                            return;

                                    }

                                        String username = authParts[0];

                                        String signature = authParts[1];

                                        user = null;

                                        try {

                                                user = getService().findUser(username);

                                        } catch (RpcException e) {

                                        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, path);

                                                return;

                                        }

                                        if (user == null) {

                                            resp.sendError(HttpServletResponse.SC_FORBIDDEN);

                                            return;

                                    }

                                        req.setAttribute(USER_ATTRIBUTE, user);

                                        // Remove the servlet path from the request URI.

                                        String p = req.getRequestURI();

                                        String servletPath = req.getContextPath() + req.getServletPath();

                                        p = p.substring(servletPath.length());

                                        // Validate the signature in the Authorization parameter.

                                        String data = req.getMethod() + dateParam + p;

                                        if (!isSignatureValid(signature, user, data)) {

                                            resp.sendError(HttpServletResponse.SC_FORBIDDEN);

                                            return;

                                    }

                                }

                        }

                        else if(folder != null && folder.isReadForAll() || file != null && file.isReadForAll()){

                                //This case refers to a folder or file with public privileges

                                //For a read-for-all folder request, pretend the owner is making it.

                                user = owner;

                                req.setAttribute(USER_ATTRIBUTE, user);

                        }else if(folder != null && !folder.isReadForAll()){

                                resp.sendError(HttpServletResponse.SC_FORBIDDEN);

                                return;

                        }

                        else{

                                resp.sendError(HttpServletResponse.SC_FORBIDDEN);

                                return;

                        }

                }

            // If the resource is not a collection, and the resource path

            // ends with "/" or "\", return NOT FOUND.

            if (folder == null)

                        if (path.endsWith("/") || path.endsWith("\\")) {

                            resp.sendError(HttpServletResponse.SC_NOT_FOUND, req.getRequestURI());

                            return;

                    }

            // Workaround for IE's broken caching behavior.

            if (folder != null)

                    resp.setHeader("Expires", "-1");

            // A request for upload progress.

            if (progress != null && content) {

                    serveProgress(req, resp, progress, user, file);

                        return;

            }

                // Fetch the version to retrieve, if specified.

                String verStr = req.getParameter(VERSION_PARAM);

                int version = 0;

                FileBody oldBody = null;

                if (verStr != null && file != null)

                        try {

                                version = Integer.valueOf(verStr);

                        } catch (NumberFormatException e) {

                                resp.sendError(HttpServletResponse.SC_BAD_REQUEST, req.getRequestURI());

                            return;

                        }

                if (version > 0)

                        try {

                                oldBody = getService().getFileVersion(user.getId(), file.getId(), version);

                        } catch (RpcException e) {

                        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, path);

                                return;

                        } catch (ObjectNotFoundException e) {

                            resp.sendError(HttpServletResponse.SC_NOT_FOUND);

                            return;

                        } catch (InsufficientPermissionsException e) {

                            resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED);

                            return;

                        }

            // Check if the conditions specified in the optional If headers are

            // satisfied. Doing this for folders would require recursive checking

            // for all of their children, which in turn would defy the purpose of

            // the optimization.

            if (folder == null){

                        // Checking If headers.

                    if (!checkIfHeaders(req, resp, file, oldBody))

                                return;

            }

            else if(!checkIfModifiedSince(req, resp, folder))

                    return;

            // Find content type.

            String contentType = null;

            boolean isContentHtml = false;

            boolean expectJSON = false;

            if (file != null) {

                contentType = version>0 ? oldBody.getMimeType() : file.getCurrentBody().getMimeType();

                if (contentType == null) {

                        contentType = context.getMimeType(file.getName());

                        file.getCurrentBody().setMimeType(contentType);

                }

            } else { // folder != null

                    String accept = req.getHeader("Accept");

                    // The order in this conditional pessimizes the common API case,

                    // but is important for backwards compatibility with existing

                    // clients who send no accept header and expect a JSON response.

                    if (accept != null && accept.contains("text/html")) {

                            contentType = "text/html;charset=UTF-8";

                            isContentHtml = true;

                            //this is the case when clients send the appropriate headers, the contentType is "text/html"

                            //and expect a JSON response. The above check applies to FireGSS client

                            expectJSON = !authDeferred ? true : false;

                    }

            else if (authDeferred && req.getMethod().equals(METHOD_GET)) {

                contentType = "text/html;charset=UTF-8";

                isContentHtml = true;

                expectJSON = false;

            }

                    else {

                            contentType = "application/json;charset=UTF-8";

                            expectJSON = true;

                    }

                }

            ArrayList ranges = null;

            long contentLength = -1L;

            if (file != null) {

                    // Parse range specifier.

                    ranges = parseRange(req, resp, file, oldBody);

                    // ETag header

                    resp.setHeader("ETag", getETag(file, oldBody));

                    // Last-Modified header.

                    String lastModified = oldBody == null ?

                                            getLastModifiedHttp(file.getAuditInfo()) :

                                            getLastModifiedHttp(oldBody.getAuditInfo());

                    resp.setHeader("Last-Modified", lastModified);

                    // X-GSS-Metadata header.

                    try {

                                resp.setHeader("X-GSS-Metadata", renderJson(user, file, oldBody));

                        } catch (InsufficientPermissionsException e) {

                                resp.setStatus(HttpServletResponse.SC_METHOD_NOT_ALLOWED);

                        return;

                }

                    // Get content length.

                    contentLength = version>0 ? oldBody.getFileSize() : file.getCurrentBody().getFileSize();

                    // Special case for zero length files, which would cause a

                    // (silent) ISE when setting the output buffer size.

                    if (contentLength == 0L)

                                content = false;

            } else

                    // Set the folder X-GSS-Metadata header.

                    try {

                                resp.setHeader("X-GSS-Metadata", renderJsonMetadata(user, folder));

                        } catch (InsufficientPermissionsException e) {

                                resp.setStatus(HttpServletResponse.SC_METHOD_NOT_ALLOWED);

                        return;

                }

            ServletOutputStream ostream = null;

            PrintWriter writer = null;

            if (content)

                        try {

                            ostream = resp.getOutputStream();

                    } catch (IllegalStateException e) {

                            // If it fails, we try to get a Writer instead if we're

                            // trying to serve a text file

                            if ( contentType == null

                                                    || contentType.startsWith("text")

                                                    || contentType.endsWith("xml") )

                                        writer = resp.getWriter();

                                else

                                        throw e;

                    }

            if (folder != null || (ranges == null || ranges.isEmpty()) && req.getHeader("Range") == null || ranges == FULL) {

                    // Set the appropriate output headers

                    if (contentType != null) {

                            if (logger.isDebugEnabled())

                                    logger.debug("contentType='" + contentType + "'");

                            resp.setContentType(contentType);

                    }

                    if (file != null && contentLength >= 0) {

                            if (logger.isDebugEnabled())

                                    logger.debug("contentLength=" + contentLength);

                            if (contentLength < Integer.MAX_VALUE)

                                        resp.setContentLength((int) contentLength);

                                else

                                        // Set the content-length as String to be able to use a long

                                    resp.setHeader("content-length", "" + contentLength);

                    }

                    InputStream renderResult = null;

                    String relativePath = getRelativePath(req);

                    String contextPath = req.getContextPath();

                    String servletPath = req.getServletPath();

                    String contextServletPath = contextPath + servletPath;

                    if (folder != null && content)

                            // Serve the directory browser for a public folder

                            if (isContentHtml && !expectJSON) {

                    try {

                        folder = getService().expandFolder(folder);

                    }

                    catch (ObjectNotFoundException e) {

                        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, path);

                        return;

                    }

                    catch (RpcException e) {

                        //We send 500 instead of 404 because this folder has been loaded before in this method and it is

                        //impossible to not be found now

                            resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, path);

                                    return;

                            }

                    renderResult = renderHtml(contextServletPath, relativePath, folder,user);

                }

                            // Serve the directory for an ordinary folder or for fireGSS client

                            else

                                    try {

                                            renderResult = renderJson(user, folder);

                                            } catch (InsufficientPermissionsException e) {

                                                    resp.setStatus(HttpServletResponse.SC_METHOD_NOT_ALLOWED);

                                                    return;

                                            }

                    // Copy the input stream to our output stream (if requested)

                    if (content) {

                            try {

                                    resp.setBufferSize(output);

                            } catch (IllegalStateException e) {

                                    // Silent catch

                            }

                            try {

                                    if(file != null)

                                                if (needsContentDisposition(req))

                                                    resp.setHeader("Content-Disposition","attachment; filename*=UTF-8''"+getDispositionFilename(file));

                                            else

                                                    resp.setHeader("Content-Disposition","inline; filename*=UTF-8''"+getDispositionFilename(file));

                                    if (ostream != null)

                                                copy(file, renderResult, ostream, req, oldBody);

                                        else

                                                copy(file, renderResult, writer, req, oldBody);

                                    if (file!=null) updateAccounting(owner, new Date(), contentLength);

                        } catch (ObjectNotFoundException e) {

                                resp.sendError(HttpServletResponse.SC_NOT_FOUND);

                                return;

                        } catch (InsufficientPermissionsException e) {

                                resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED);

                                return;

                        } catch (RpcException e) {

                                resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);

                                return;

                            }

                    }

            } else {

                    if (ranges == null || ranges.isEmpty())

                            return;

                    // Partial content response.

                    resp.setStatus(HttpServletResponse.SC_PARTIAL_CONTENT);

                    if (ranges.size() == 1) {

                            Range range = (Range) ranges.get(0);

                            resp.addHeader("Content-Range", "bytes "

                                                    + range.start

                                                    + "-" + range.end + "/"

                                                    + range.length);

                            long length = range.end - range.start + 1;

                            if (length < Integer.MAX_VALUE)

                                        resp.setContentLength((int) length);

                                else

                                        // Set the content-length as String to be able to use a long

                                    resp.setHeader("content-length", "" + length);

                            if (contentType != null) {

                                    if (logger.isDebugEnabled())

                                            logger.debug("contentType='" + contentType + "'");

                                    resp.setContentType(contentType);

                            }

                            if (content) {

                                    try {

                                            resp.setBufferSize(output);

                                    } catch (IllegalStateException e) {

                                            // Silent catch

                                    }

                                    try {

                                            if (ostream != null)

                                                        copy(file, ostream, range, req, oldBody);

                                                else

                                                        copy(file, writer, range, req, oldBody);

                                            updateAccounting(owner, new Date(), contentLength);

                                } catch (ObjectNotFoundException e) {

                                        resp.sendError(HttpServletResponse.SC_NOT_FOUND);

                                        return;

                                } catch (InsufficientPermissionsException e) {

                                        resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED);

                                        return;

                                } catch (RpcException e) {

                                        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);

                                        return;

                                }

                            }

                    } else {

                            resp.setContentType("multipart/byteranges; boundary=" + mimeSeparation);

                            if (content) {

                                    try {

                                            resp.setBufferSize(output);

                                    } catch (IllegalStateException e) {

                                            // Silent catch

                                    }

                                    try {

                                            if (ostream != null)

                                                        copy(file, ostream, ranges.iterator(), contentType, req, oldBody);

                                                else

                                                        copy(file, writer, ranges.iterator(), contentType, req, oldBody);

                                            updateAccounting(owner, new Date(), contentLength);

                                } catch (ObjectNotFoundException e) {

                                        resp.sendError(HttpServletResponse.SC_NOT_FOUND);

                                        return;

                                } catch (InsufficientPermissionsException e) {

                                        resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED);

                                        return;

                                } catch (RpcException e) {

                                        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);

                                        return;

                                }

                            }

                    }

            }

    }

        /**

         * Handles an authentication failure. If no Authorization or Date request

         * parameters and no Authorization, Date or X-GSS-Date headers were present,

         * this is a browser request, so redirect to login and then let the user get

         * back to the file. Otherwise it's a bogus client request and Forbidden is

         * returned.

         */

        private void handleAuthFailure(HttpServletRequest req, HttpServletResponse resp) throws IOException {

                if (req.getParameter(AUTHORIZATION_PARAMETER) == null &&

                                req.getParameter(DATE_PARAMETER) == null &&

                                req.getHeader(AUTHORIZATION_HEADER) == null &&

                                req.getDateHeader(DATE_HEADER) == -1 &&

                                req.getDateHeader(GSS_DATE_HEADER) == -1)

                        resp.sendRedirect(getConfiguration().getString("loginUrl") +

                                        "?next=" + req.getRequestURL().toString());

                else

                        resp.sendError(HttpServletResponse.SC_FORBIDDEN);

        }

        /**

         * Return the filename of the specified file properly formatted for

         * including in the Content-Disposition header.

         */

        private String getDispositionFilename(FileHeader file) throws UnsupportedEncodingException {

                return URLEncoder.encode(file.getName(),"UTF-8").replaceAll("\\+", "%20");

        }

        /**

         * Determines whether the user agent needs the Content-Disposition

         * header to be set, in order to properly download a file.

         *

         * @param req the HTTP request

         * @return true if the Content-Disposition HTTP header must be set

         */

        private boolean needsContentDisposition(HttpServletRequest req) {

                /*String agent = req.getHeader("user-agent");

                if (agent != null && agent.contains("MSIE"))

                        return true;*/

                String dl = req.getParameter("dl");

                if ("1".equals(dl))

                        return true;

                return false;

        }

        /**

         * Sends a progress update on the amount of bytes received until now for

         * a file that the current user is currently uploading.

         *

         * @param req the HTTP request

         * @param resp the HTTP response

         * @param parameter the value for the progress request parameter

         * @param user the current user

         * @param file the file being uploaded, or null if the request is about a new file

         * @throws IOException if an I/O error occurs

         */

        private void serveProgress(HttpServletRequest req, HttpServletResponse resp,

                                String parameter, User user, FileHeader file)        throws IOException {

                String filename = file == null ? parameter : file.getName();

                try {

                        FileUploadStatus status = getService().getFileUploadStatus(user.getId(), filename);

                        if (status == null) {

                                resp.sendError(HttpServletResponse.SC_NOT_FOUND);

                                return;

                        }

                        JSONObject json = new JSONObject();

                        json.put("bytesUploaded", status.getBytesUploaded()).

                                put("bytesTotal", status.getFileSize());

                        sendJson(req, resp, json.toString());

                        // Workaround for IE's broken caching behavior.

                    resp.setHeader("Expires", "-1");

                        return;

                } catch (RpcException e) {

                        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);

                        return;

                } catch (JSONException e) {

                        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage());

                        return;

                }

        }

        /**

         * Server a POST request to create/modify a file or folder.

         *

         * @param req the HTTP request

         * @param resp the HTTP response

     * @exception IOException if an input/output error occurs

         */

        void postResource(HttpServletRequest req, HttpServletResponse resp) throws IOException {

                boolean authDeferred = getAuthDeferred(req);

            if (!authDeferred && req.getParameterMap().size() > 1) {

                    resp.sendError(HttpServletResponse.SC_BAD_REQUEST);

                    return;

            }

        String path = getInnerPath(req, PATH_FILES);

            path = path.endsWith("/")? path: path + '/';

                try {

                    path = URLDecoder.decode(path, "UTF-8");

                } catch (IllegalArgumentException e) {

                        resp.sendError(HttpServletResponse.SC_BAD_REQUEST, e.getMessage());

                        return;

                }

            // We only defer authenticating multipart POST requests.

            if (authDeferred) {

                        if (!ServletFileUpload.isMultipartContent(req)) {

                            resp.sendError(HttpServletResponse.SC_FORBIDDEN);

                            return;

                    }

                        handleMultipart(req, resp, path);

                        return;

                }

            String newName = req.getParameter(NEW_FOLDER_PARAMETER);

            boolean hasUpdateParam = req.getParameterMap().containsKey(RESOURCE_UPDATE_PARAMETER);

            boolean hasTrashParam = req.getParameterMap().containsKey(RESOURCE_TRASH_PARAMETER);

            boolean hasRestoreParam = req.getParameterMap().containsKey(RESOURCE_RESTORE_PARAMETER);

            String copyTo = req.getParameter(RESOURCE_COPY_PARAMETER);

            String moveTo = req.getParameter(RESOURCE_MOVE_PARAMETER);

            String restoreVersion = req.getParameter(RESTORE_VERSION_PARAMETER);

            if (newName != null){

                if (!isValidResourceName(newName)) {

                        resp.sendError(HttpServletResponse.SC_BAD_REQUEST);

                        return;

                }

                        createFolder(req, resp, path, newName);

            }

            else if (hasUpdateParam)

                        updateResource(req, resp, path);

                else if (hasTrashParam)

                        trashResource(req, resp, path);

                else if (hasRestoreParam)

                        restoreResource(req, resp, path);

                else if (copyTo != null)

                        copyResource(req, resp, path, copyTo);

                else if (moveTo != null)

                        moveResource(req, resp, path, moveTo);

                else if (restoreVersion != null)

                        restoreVersion(req, resp, path, restoreVersion);

                else

                        // IE with Gears uses POST for multiple uploads.

                        putResource(req, resp);

        }

        /**

         * Restores a previous version for a file.

         *

         * @param req the HTTP request

         * @param resp the HTTP response

         * @param path the resource path

         * @param version the version number to restore

         * @throws IOException if an I/O error occurs

         */

        private void restoreVersion(HttpServletRequest req, HttpServletResponse resp, String path, String version) throws IOException {

                final User user = getUser(req);

                User owner = getOwner(req);

                Object resource = null;

                try {

                        resource = getService().getResourceAtPath(owner.getId(), path, true);

                } catch (ObjectNotFoundException e) {

                        resp.sendError(HttpServletResponse.SC_NOT_FOUND, path);

                        return;

                } catch (RpcException e) {

                        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, path);

                        return;

                }

                if (resource instanceof Folder) {

                        resp.sendError(HttpServletResponse.SC_CONFLICT);

                        return;

                }

                try {

                        final FileHeader file = (FileHeader) resource;

                        final int oldVersion = Integer.parseInt(version);

                        new TransactionHelper<Void>().tryExecute(new Callable<Void>() {

                                @Override

                                public Void call() throws Exception {

                                        getService().restoreVersion(user.getId(), file.getId(), oldVersion);

                                        return null;

                                }

                        });

                } catch (InsufficientPermissionsException e) {

                        resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED);

                } catch (ObjectNotFoundException e) {

                        resp.sendError(HttpServletResponse.SC_NOT_FOUND, e.getMessage());

                } catch (RpcException e) {

                        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, path);

                } catch (GSSIOException e) {

                        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage());

                } catch (QuotaExceededException e) {

                        resp.sendError(HttpServletResponse.SC_REQUEST_ENTITY_TOO_LARGE, e.getMessage());

                } catch (NumberFormatException e) {

                        resp.sendError(HttpServletResponse.SC_BAD_REQUEST, e.getMessage());

                } catch (Exception e) {

                        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage());

                }

        }

        /**

         * A method for handling multipart POST requests for uploading

         * files from browser-based JavaScript clients.

         *

         * @param request the HTTP request

         * @param response the HTTP response