Synnefo » Pithos

/*

 * Copyright 2007, 2008, 2009 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.webdav;

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

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

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

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

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

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

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

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

import gr.ebs.gss.server.domain.dto.AuditInfoDTO;

import gr.ebs.gss.server.domain.dto.FileBodyDTO;

import gr.ebs.gss.server.domain.dto.FileHeaderDTO;

import gr.ebs.gss.server.domain.dto.FolderDTO;

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

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

import java.io.BufferedInputStream;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.io.PrintWriter;

import java.io.RandomAccessFile;

import java.io.Reader;

import java.io.StringReader;

import java.io.StringWriter;

import java.io.UnsupportedEncodingException;

import java.io.Writer;

import java.net.URLDecoder;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Date;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.List;

import java.util.Locale;

import java.util.Stack;

import java.util.StringTokenizer;

import java.util.TimeZone;

import java.util.Vector;

import java.util.concurrent.Callable;

import javax.naming.Context;

import javax.naming.InitialContext;

import javax.naming.NamingException;

import javax.rmi.PortableRemoteObject;

import javax.servlet.ServletContext;

import javax.servlet.ServletException;

import javax.servlet.ServletOutputStream;

import javax.servlet.UnavailableException;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

import org.apache.commons.httpclient.HttpStatus;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

import org.xml.sax.EntityResolver;

import org.xml.sax.InputSource;

import org.xml.sax.SAXException;

/**

 * The implementation of the WebDAV service.

 *

 * @author past

 */

public class Webdav extends HttpServlet {

        /**

         * The request attribute containing the user who owns the requested

         * namespace.

         */

        protected static final String OWNER_ATTRIBUTE = "owner";

        /**

         * The request attribute containing the user making the request.

         */

        protected static final String USER_ATTRIBUTE = "user";

        /**

         * The logger.

         */

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

        /**

     *

     */

        protected static final String METHOD_GET = "GET";

        /**

     *

     */

        protected static final String METHOD_POST = "POST";

        /**

     *

     */

        protected static final String METHOD_PUT = "PUT";

        /**

     *

     */

        protected static final String METHOD_DELETE = "DELETE";

        /**

     *

     */

        protected static final String METHOD_HEAD = "HEAD";

        /**

     *

     */

        private static final String METHOD_OPTIONS = "OPTIONS";

        /**

     *

     */

        private static final String METHOD_PROPFIND = "PROPFIND";

        /**

     *

     */

        private static final String METHOD_PROPPATCH = "PROPPATCH";

        /**

     *

     */

        private static final String METHOD_MKCOL = "MKCOL";

        /**

     *

     */

        private static final String METHOD_COPY = "COPY";

        /**

     *

     */

        private static final String METHOD_MOVE = "MOVE";

        /**

     *

     */

        private static final String METHOD_LOCK = "LOCK";

        /**

     *

     */

        private static final String METHOD_UNLOCK = "UNLOCK";

        /**

         * Default depth is infinite.

         */

        static final int INFINITY = 3; // To limit tree browsing a bit

        /**

         * PROPFIND - Specify a property mask.

         */

        private static final int FIND_BY_PROPERTY = 0;

        /**

         * PROPFIND - Display all properties.

         */

        private static final int FIND_ALL_PROP = 1;

        /**

         * PROPFIND - Return property names.

         */

        private static final int FIND_PROPERTY_NAMES = 2;

        /**

         * Default namespace.

         */

        private static final String DEFAULT_NAMESPACE = "DAV:";

        /**

         * Create a new lock.

         */

        private static final int LOCK_CREATION = 0;

        /**

         * Refresh lock.

         */

        private static final int LOCK_REFRESH = 1;

        /**

         * Default lock timeout value.

         */

        private static final int DEFAULT_TIMEOUT = 3600;

        /**

         * Maximum lock timeout.

         */

        private static final int MAX_TIMEOUT = 604800;

        /**

         * Size of file transfer buffer in bytes.

         */

        private static final int BUFFER_SIZE = 4096;

        /**

         * The output buffer size to use when serving resources.

         */

        protected int output = 2048;

        /**

         * The input buffer size to use when serving resources.

         */

        private int input = 2048;

        /**

         * MIME multipart separation string

         */

        protected static final String mimeSeparation = "GSS_MIME_BOUNDARY";

        /**

         * Simple date format for the creation date ISO representation (partial).

         */

        private static final SimpleDateFormat creationDateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");

        /**

         * HTTP date format.

         */

        private static final SimpleDateFormat format = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US);

        /**

         * Array containing the safe characters set.

         */

        private static URLEncoder urlEncoder;

        /**

         * File encoding to be used when reading static files. If none is specified

         * the platform default is used.

         */

        private String fileEncoding = null;

        /**

         * 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;}";

        /**

         * Secret information used to generate reasonably secure lock ids.

         */

        private String secret = "gss-webdav";

        /**

         * Full range marker.

         */

        protected static ArrayList FULL = new ArrayList();

        /**

         * MD5 message digest provider.

         */

        protected static MessageDigest md5Helper;

        /**

         * The MD5 helper object for this class.

         */

        protected static final MD5Encoder md5Encoder = new MD5Encoder();

        /**

         * GMT timezone - all HTTP dates are on GMT

         */

        static {

                creationDateFormat.setTimeZone(TimeZone.getTimeZone("GMT"));

                urlEncoder = new URLEncoder();

                urlEncoder.addSafeCharacter('-');

                urlEncoder.addSafeCharacter('_');

                urlEncoder.addSafeCharacter('.');

                urlEncoder.addSafeCharacter('*');

                urlEncoder.addSafeCharacter('/');

        }

        @Override

        public void init() throws ServletException {

                if (getServletConfig().getInitParameter("input") != null)

                        input = Integer.parseInt(getServletConfig().getInitParameter("input"));

                if (getServletConfig().getInitParameter("output") != null)

                        output = Integer.parseInt(getServletConfig().getInitParameter("output"));

                fileEncoding = getServletConfig().getInitParameter("fileEncoding");

                // Sanity check on the specified buffer sizes

                if (input < 256)

                        input = 256;

                if (output < 256)

                        output = 256;

                if (logger.isDebugEnabled())

                        logger.debug("Input buffer size=" + input + ", output buffer size=" + output);

                if (getServletConfig().getInitParameter("secret") != null)

                        secret = getServletConfig().getInitParameter("secret");

                // Load the MD5 helper used to calculate signatures.

                try {

                        md5Helper = MessageDigest.getInstance("MD5");

                } catch (NoSuchAlgorithmException e) {

                        throw new UnavailableException("No MD5");

                }

        }

        /**

         * A helper method that retrieves a reference to the ExternalAPI bean and

         * stores it for future use.

         *

         * @return an ExternalAPI instance

         * @throws RpcException in case an error occurs

         */

        protected ExternalAPI getService() throws RpcException {

                try {

                        final Context ctx = new InitialContext();

                        final Object ref = ctx.lookup(getConfiguration().getString("externalApiPath"));

                        return (ExternalAPI) PortableRemoteObject.narrow(ref, ExternalAPI.class);

                } catch (final NamingException e) {

                        logger.error("Unable to retrieve the ExternalAPI EJB", e);

                        throw new RpcException("An error occurred while contacting the naming service");

                }

        }

        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;

                }

        }

        @Override

        public void service(final HttpServletRequest request, final HttpServletResponse response) throws IOException, ServletException {

                String method = request.getMethod();

                if (logger.isDebugEnabled()) {

                        String path = request.getPathInfo();

                        if (path == null)

                                path = request.getServletPath();

                        if (path == null || path.equals(""))

                                path = "/";

                        logger.debug("[" + method + "] " + path);

                }

                try {

                        User user = null;

                        if (request.getUserPrincipal() != null) { // Let unauthenticated

                                                                                                                // OPTIONS go through;

                                                                                                                // all others will be

                                                                                                                // blocked by

                                                                                                                // authentication anyway

                                                                                                                // before we get here.

                                user = getService().findUser(request.getUserPrincipal().getName());

                                if (user == null) {

                                        response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);

                                        return;

                                }

                        }

                        request.setAttribute(USER_ATTRIBUTE, user);

                        request.setAttribute(OWNER_ATTRIBUTE, user);

                } catch (RpcException e) {

                        response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);

                        return;

                }

                if (method.equals(METHOD_GET))

                        doGet(request, response);

                else if (method.equals(METHOD_POST))

                        doPost(request, response);

                else if (method.equals(METHOD_PUT))

                        doPut(request, response);

                else if (method.equals(METHOD_DELETE))

                        doDelete(request, response);

                else if (method.equals(METHOD_HEAD))

                        doHead(request, response);

                else if (method.equals(METHOD_PROPFIND))

                        doPropfind(request, response);

                else if (method.equals(METHOD_PROPPATCH))

                        doProppatch(request, response);

                else if (method.equals(METHOD_MKCOL))

                        doMkcol(request, response);

                else if (method.equals(METHOD_COPY))

                        doCopy(request, response);

                else if (method.equals(METHOD_MOVE))

                        doMove(request, response);

                else if (method.equals(METHOD_LOCK))

                        doLock(request, response);

                else if (method.equals(METHOD_UNLOCK))

                        doUnlock(request, response);

                else if (method.equals(METHOD_OPTIONS))

                        doOptions(request, response);

                else

                        // DefaultServlet processing for TRACE, etc.

                        super.service(request, response);

        }

        @Override

        protected void doOptions(HttpServletRequest req, HttpServletResponse resp) throws IOException {

                resp.addHeader("DAV", "1,2");

                StringBuffer methodsAllowed = new StringBuffer();

                try {

                        methodsAllowed = determineMethodsAllowed(req);

                } catch (RpcException e) {

                        resp.sendError(HttpStatus.SC_INTERNAL_SERVER_ERROR);

                        return;

                }

                resp.addHeader("Allow", methodsAllowed.toString());

                resp.addHeader("MS-Author-Via", "DAV");

        }

        /**

         * Implement the PROPFIND method.

         *

         * @param req the HTTP request

         * @param resp the HTTP response

         * @throws ServletException

         * @throws IOException

         */

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

                String path = getRelativePath(req);

                if (path.endsWith("/") && !path.equals("/"))

                        path = path.substring(0, path.length() - 1);

                if (path.toUpperCase().startsWith("/WEB-INF") || path.toUpperCase().startsWith("/META-INF")) {

                        resp.sendError(WebdavStatus.SC_FORBIDDEN);

                        return;

                }

                // Properties which are to be displayed.

                Vector<String> properties = null;

                // Propfind depth

                int depth = INFINITY;

                // Propfind type

                int type = FIND_ALL_PROP;

                String depthStr = req.getHeader("Depth");

                if (depthStr == null)

                        depth = INFINITY;

                else if (depthStr.equals("0"))

                        depth = 0;

                else if (depthStr.equals("1"))

                        depth = 1;

                else if (depthStr.equals("infinity"))

                        depth = INFINITY;

                Node propNode = null;

                if (req.getInputStream().available() > 0) {

                        DocumentBuilder documentBuilder = getDocumentBuilder();

                        try {

                                Document document = documentBuilder.parse(new InputSource(req.getInputStream()));

                                // Get the root element of the document

                                Element rootElement = document.getDocumentElement();

                                NodeList childList = rootElement.getChildNodes();

                                for (int i = 0; i < childList.getLength(); i++) {

                                        Node currentNode = childList.item(i);

                                        switch (currentNode.getNodeType()) {

                                                case Node.TEXT_NODE:

                                                        break;

                                                case Node.ELEMENT_NODE:

                                                        if (currentNode.getNodeName().endsWith("prop")) {

                                                                type = FIND_BY_PROPERTY;

                                                                propNode = currentNode;

                                                        }

                                                        if (currentNode.getNodeName().endsWith("propname"))

                                                                type = FIND_PROPERTY_NAMES;

                                                        if (currentNode.getNodeName().endsWith("allprop"))

                                                                type = FIND_ALL_PROP;

                                                        break;

                                        }

                                }

                        } catch (SAXException e) {

                                // Something went wrong - use the defaults.

                                if (logger.isDebugEnabled())

                                        logger.debug(e.getMessage());

                        } catch (IOException e) {

                                // Something went wrong - use the defaults.

                                if (logger.isDebugEnabled())

                                        logger.debug(e.getMessage());

                        }

                }

                if (type == FIND_BY_PROPERTY) {

                        properties = new Vector<String>();

                        NodeList childList = propNode.getChildNodes();

                        for (int i = 0; i < childList.getLength(); i++) {

                                Node currentNode = childList.item(i);

                                switch (currentNode.getNodeType()) {

                                        case Node.TEXT_NODE:

                                                break;

                                        case Node.ELEMENT_NODE:

                                                String nodeName = currentNode.getNodeName();

                                                String propertyName = null;

                                                if (nodeName.indexOf(':') != -1)

                                                        propertyName = nodeName.substring(nodeName.indexOf(':') + 1);

                                                else

                                                        propertyName = nodeName;

                                                // href is a live property which is handled differently

                                                properties.addElement(propertyName);

                                                break;

                                }

                        }

                }

                User user = getUser(req);

                boolean exists = true;

                Object object = null;

                try {

                        object = getService().getResourceAtPath(user.getId(), path, true);

                } catch (ObjectNotFoundException e) {

                        exists = false;

                } catch (RpcException e) {

                        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, path);

                        return;

                }

                if (!exists) {

                        resp.sendError(HttpServletResponse.SC_NOT_FOUND, path);

                        return;

                }

                resp.setStatus(WebdavStatus.SC_MULTI_STATUS);

                resp.setContentType("text/xml; charset=UTF-8");

                // Create multistatus object

                XMLWriter generatedXML = new XMLWriter(resp.getWriter());

                generatedXML.writeXMLHeader();

                generatedXML.writeElement(null, "D:multistatus" + generateNamespaceDeclarations(), XMLWriter.OPENING);

                if (depth == 0)

                        parseProperties(req, generatedXML, path, type, properties, object);

                else {

                        // The stack always contains the object of the current level

                        Stack<String> stack = new Stack<String>();

                        stack.push(path);

                        // Stack of the objects one level below

                        Stack<String> stackBelow = new Stack<String>();

                        while (!stack.isEmpty() && depth >= 0) {

                                String currentPath = stack.pop();

                                try {

                                        object = getService().getResourceAtPath(user.getId(), currentPath, true);

                                } catch (ObjectNotFoundException e) {

                                        continue;

                                } catch (RpcException e) {

                                        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, path);

                                        return;

                                }

                                parseProperties(req, generatedXML, currentPath, type, properties, object);

                                if (object instanceof FolderDTO && depth > 0) {

                                        FolderDTO folder = (FolderDTO) object;

                                        // Retrieve the subfolders.

                                        List subfolders = folder.getSubfolders();

                                        Iterator iter = subfolders.iterator();

                                        while (iter.hasNext()) {

                                                FolderDTO f = (FolderDTO) iter.next();

                                                String newPath = currentPath;

                                                if (!newPath.endsWith("/"))

                                                        newPath += "/";

                                                newPath += f.getName();

                                                stackBelow.push(newPath);

                                        }

                                        // Retrieve the files.

                                        List<FileHeaderDTO> files;

                                        try {

                                                files = getService().getFiles(user.getId(), folder.getId(), true);

                                        } catch (ObjectNotFoundException e) {

                                                resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, path);

                                                return;

                                        } catch (InsufficientPermissionsException e) {

                                                resp.sendError(HttpServletResponse.SC_FORBIDDEN, path);

                                                return;

                                        } catch (RpcException e) {

                                                resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, path);

                                                return;

                                        }

                                        for (FileHeaderDTO file : files) {

                                                String newPath = currentPath;

                                                if (!newPath.endsWith("/"))

                                                        newPath += "/";

                                                newPath += file.getName();

                                                stackBelow.push(newPath);

                                        }

                                }

                                if (stack.isEmpty()) {

                                        depth--;

                                        stack = stackBelow;

                                        stackBelow = new Stack<String>();

                                }

                                generatedXML.sendData();

                        }

                }

                generatedXML.writeElement(null, "D:multistatus", XMLWriter.CLOSING);

                generatedXML.sendData();

        }

        /**

         * PROPPATCH Method.

         *

         * @param req the HTTP request

         * @param resp the HTTP response

         * @throws IOException if an error occurs while sending the response

         */

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

                if (isLocked(req)) {

                        resp.sendError(WebdavStatus.SC_LOCKED);

                        return;

                }

                resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED);

        }

        @Override

        protected void doDelete(HttpServletRequest req, HttpServletResponse resp) throws IOException {

                if (isLocked(req)) {

                        resp.sendError(WebdavStatus.SC_LOCKED);

                        return;

                }

                deleteResource(req, resp);

        }

        @Override

        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {

                // Serve the requested resource, including the data content

                try {

                        serveResource(req, resp, true);

                } catch (ObjectNotFoundException e) {

                        resp.sendError(HttpServletResponse.SC_NOT_FOUND);

                        return;

                } catch (InsufficientPermissionsException e) {

                        resp.sendError(HttpServletResponse.SC_FORBIDDEN);

                        return;

                } catch (RpcException e) {

                        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);

                        return;

                }

        }

        @Override

        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {

                resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED);

        }

        @Override

        protected void doPut(HttpServletRequest req, HttpServletResponse resp) throws IOException {

                if (isLocked(req)) {

                        resp.sendError(WebdavStatus.SC_LOCKED);

                        return;

                }

                final User user = getUser(req);

                String path = getRelativePath(req);

                boolean exists = true;

                Object resource = null;

                FileHeaderDTO file = null;

                try {

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

                } catch (ObjectNotFoundException e) {

                        exists = false;

                } catch (RpcException e) {

                        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, path);

                        return;

                }

                if (exists)

                        if (resource instanceof FileHeaderDTO)

                                file = (FileHeaderDTO) resource;

                        else {

                                resp.sendError(HttpServletResponse.SC_CONFLICT);

                                return;

                        }

                boolean result = true;

                // Temporary content file used to support partial PUT.

                File contentFile = null;

                Range range = parseContentRange(req, resp);

                InputStream resourceInputStream = null;

                // Append data specified in ranges to existing content for this

                // resource - create a temporary file on the local filesystem to

                // perform this operation.

                // Assume just one range is specified for now

                if (range != null) {

                        try {

                                contentFile = executePartialPut(req, range, path);

                        } catch (RpcException e) {

                                resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, path);

                                return;

                        } catch (ObjectNotFoundException e) {

                                resp.sendError(HttpServletResponse.SC_CONFLICT);

                                return;

                        } catch (InsufficientPermissionsException e) {

                                resp.sendError(HttpServletResponse.SC_FORBIDDEN);

                                return;

                        }

                        resourceInputStream = new FileInputStream(contentFile);

                } else

                        resourceInputStream = req.getInputStream();

                try {

                        Object parent = getService().getResourceAtPath(user.getId(), getParentPath(path), true);

                        if (!(parent instanceof FolderDTO)) {

                                resp.sendError(HttpServletResponse.SC_CONFLICT);

                                return;

                        }

                        final FolderDTO folder = (FolderDTO) parent;

                        final String name = getLastElement(path);

                        final String mimeType = getServletContext().getMimeType(name);

                File uploadedFile = null;

                try {

                                uploadedFile = getService().uploadFile(resourceInputStream, user.getId());

                        } catch (IOException ex) {

                                throw new GSSIOException(ex, false);

                        }

                        // FIXME: Add attributes

                        FileHeaderDTO fileDTO = null;

                        final FileHeaderDTO f = file;

                        final File uf = uploadedFile;

                        if (exists)

                                fileDTO = new TransactionHelper<FileHeaderDTO>().tryExecute(new Callable<FileHeaderDTO>() {

                                        @Override

                                        public FileHeaderDTO call() throws Exception {

                                                return getService().updateFileContents(user.getId(), f.getId(), mimeType, uf.length(), uf.getAbsolutePath());

                                        }

                                });

                        else

                                fileDTO = new TransactionHelper<FileHeaderDTO>().tryExecute(new Callable<FileHeaderDTO>() {

                                        @Override

                                        public FileHeaderDTO call() throws Exception {

                                                return getService().createFile(user.getId(), folder.getId(), name, mimeType, uf.length(), uf.getAbsolutePath());

                                        }

                                });

                        updateAccounting(user, new Date(), fileDTO.getFileSize());

                } catch (ObjectNotFoundException e) {

                        result = false;

                } catch (InsufficientPermissionsException e) {

                        resp.sendError(HttpServletResponse.SC_FORBIDDEN);

                        return;

                } catch (QuotaExceededException e) {

                        resp.sendError(HttpServletResponse.SC_FORBIDDEN);

                        return;

                } catch (GSSIOException e) {

                        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, path);

                        return;

                } catch (RpcException e) {

                        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, path);

                        return;

                } catch (DuplicateNameException e) {

                        resp.sendError(HttpServletResponse.SC_CONFLICT);

                        return;

                } catch (Exception e) {

                        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, path);

                        return;

                }

                if (result) {

                        if (exists)

                                resp.setStatus(HttpServletResponse.SC_NO_CONTENT);

                        else

                                resp.setStatus(HttpServletResponse.SC_CREATED);

                } else

                        resp.sendError(HttpServletResponse.SC_CONFLICT);

        }

        @Override

        protected void doHead(HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {

                // Serve the requested resource, without the data content

                try {

                        serveResource(req, resp, false);

                } catch (ObjectNotFoundException e) {

                        resp.sendError(HttpServletResponse.SC_NOT_FOUND);

                        return;

                } catch (InsufficientPermissionsException e) {

                        resp.sendError(HttpServletResponse.SC_FORBIDDEN);

                        return;

                } catch (RpcException e) {

                        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);

                        return;

                }

        }

        /**

         * The UNLOCK method.

         *

         * @param req the HTTP request

         * @param resp the HTTP response

         * @throws IOException if an error occurs while sending the response

         */

        private void doUnlock(@SuppressWarnings("unused") HttpServletRequest req, HttpServletResponse resp) throws IOException {

                resp.setStatus(WebdavStatus.SC_NO_CONTENT);

        }

        /**

         * The LOCK method.

         *

         * @param req the HTTP request

         * @param resp the HTTP response

         * @throws IOException if an error occurs while sending the response

         * @throws ServletException

         */

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

                LockInfo lock = new LockInfo();

                // Parsing lock request

                // Parsing depth header

                String depthStr = req.getHeader("Depth");

                if (depthStr == null)

                        lock.depth = INFINITY;

                else if (depthStr.equals("0"))

                        lock.depth = 0;

                else

                        lock.depth = INFINITY;

                // Parsing timeout header

                int lockDuration = DEFAULT_TIMEOUT;

                String lockDurationStr = req.getHeader("Timeout");

                if (lockDurationStr == null)

                        lockDuration = DEFAULT_TIMEOUT;

                else {

                        int commaPos = lockDurationStr.indexOf(",");

                        // If multiple timeouts, just use the first

                        if (commaPos != -1)

                                lockDurationStr = lockDurationStr.substring(0, commaPos);

                        if (lockDurationStr.startsWith("Second-"))

                                lockDuration = new Integer(lockDurationStr.substring(7)).intValue();

                        else if (lockDurationStr.equalsIgnoreCase("infinity"))

                                lockDuration = MAX_TIMEOUT;

                        else

                                try {

                                        lockDuration = new Integer(lockDurationStr).intValue();

                                } catch (NumberFormatException e) {

                                        lockDuration = MAX_TIMEOUT;

                                }

                        if (lockDuration == 0)

                                lockDuration = DEFAULT_TIMEOUT;

                        if (lockDuration > MAX_TIMEOUT)

                                lockDuration = MAX_TIMEOUT;

                }

                lock.expiresAt = System.currentTimeMillis() + lockDuration * 1000;

                int lockRequestType = LOCK_CREATION;

                Node lockInfoNode = null;

                DocumentBuilder documentBuilder = getDocumentBuilder();

                try {

                        Document document = documentBuilder.parse(new InputSource(req.getInputStream()));

                        // Get the root element of the document

                        Element rootElement = document.getDocumentElement();

                        lockInfoNode = rootElement;

                } catch (IOException e) {

                        lockRequestType = LOCK_REFRESH;

                } catch (SAXException e) {

                        lockRequestType = LOCK_REFRESH;

                }

                if (lockInfoNode != null) {

                        // Reading lock information

                        NodeList childList = lockInfoNode.getChildNodes();

                        StringWriter strWriter = null;

                        DOMWriter domWriter = null;

                        Node lockScopeNode = null;

                        Node lockTypeNode = null;

                        Node lockOwnerNode = null;

                        for (int i = 0; i < childList.getLength(); i++) {

                                Node currentNode = childList.item(i);

                                switch (currentNode.getNodeType()) {

                                        case Node.TEXT_NODE:

                                                break;

                                        case Node.ELEMENT_NODE:

                                                String nodeName = currentNode.getNodeName();

                                                if (nodeName.endsWith("lockscope"))

                                                        lockScopeNode = currentNode;

                                                if (nodeName.endsWith("locktype"))

                                                        lockTypeNode = currentNode;

                                                if (nodeName.endsWith("owner"))

                                                        lockOwnerNode = currentNode;

                                                break;

                                }

                        }

                        if (lockScopeNode != null) {

                                childList = lockScopeNode.getChildNodes();

                                for (int i = 0; i < childList.getLength(); i++) {

                                        Node currentNode = childList.item(i);

                                        switch (currentNode.getNodeType()) {

                                                case Node.TEXT_NODE:

                                                        break;

                                                case Node.ELEMENT_NODE:

                                                        String tempScope = currentNode.getNodeName();

                                                        if (tempScope.indexOf(':') != -1)

                                                                lock.scope = tempScope.substring(tempScope.indexOf(':') + 1);

                                                        else

                                                                lock.scope = tempScope;

                                                        break;

                                        }

                                }

                                if (lock.scope == null)

                                        // Bad request

                                        resp.setStatus(WebdavStatus.SC_BAD_REQUEST);

                        } else

                                // Bad request

                                resp.setStatus(WebdavStatus.SC_BAD_REQUEST);

                        if (lockTypeNode != null) {

                                childList = lockTypeNode.getChildNodes();

                                for (int i = 0; i < childList.getLength(); i++) {

                                        Node currentNode = childList.item(i);

                                        switch (currentNode.getNodeType()) {

                                                case Node.TEXT_NODE:

                                                        break;

                                                case Node.ELEMENT_NODE:

                                                        String tempType = currentNode.getNodeName();

                                                        if (tempType.indexOf(':') != -1)

                                                                lock.type = tempType.substring(tempType.indexOf(':') + 1);

                                                        else

                                                                lock.type = tempType;

                                                        break;

                                        }

                                }

                                if (lock.type == null)

                                        // Bad request

                                        resp.setStatus(WebdavStatus.SC_BAD_REQUEST);

                        } else

                                // Bad request

                                resp.setStatus(WebdavStatus.SC_BAD_REQUEST);

                        if (lockOwnerNode != null) {

                                childList = lockOwnerNode.getChildNodes();

                                for (int i = 0; i < childList.getLength(); i++) {

                                        Node currentNode = childList.item(i);

                                        switch (currentNode.getNodeType()) {

                                                case Node.TEXT_NODE:

                                                        lock.owner += currentNode.getNodeValue();

                                                        break;

                                                case Node.ELEMENT_NODE:

                                                        strWriter = new StringWriter();

                                                        domWriter = new DOMWriter(strWriter, true);

                                                        domWriter.setQualifiedNames(false);

                                                        domWriter.print(currentNode);

                                                        lock.owner += strWriter.toString();

                                                        break;

                                        }

                                }

                                if (lock.owner == null)

                                        // Bad request

                                        resp.setStatus(WebdavStatus.SC_BAD_REQUEST);

                        } else

                                lock.owner = new String();

                }

                String path = getRelativePath(req);

                lock.path = path;

                User user = getUser(req);

                boolean exists = true;

                Object object = null;

                try {

                        object = getService().getResourceAtPath(user.getId(), path, true);

                } catch (ObjectNotFoundException e) {

                        exists = false;

                } catch (RpcException e) {

                        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, path);

                        return;

                }

                if (lockRequestType == LOCK_CREATION) {

                        // Generating lock id

                        String lockTokenStr = req.getServletPath() + "-" + lock.type + "-" + lock.scope + "-" + req.getUserPrincipal() + "-" + lock.depth + "-" + lock.owner + "-" + lock.tokens + "-" + lock.expiresAt + "-" + System.currentTimeMillis() + "-" + secret;

                        String lockToken = md5Encoder.encode(md5Helper.digest(lockTokenStr.getBytes()));

                        if (exists && object instanceof FolderDTO && lock.depth == INFINITY)

                                // Locking a collection (and all its member resources)

                                lock.tokens.addElement(lockToken);

                        else {

                                // Locking a single resource

                                lock.tokens.addElement(lockToken);

                                // Add the Lock-Token header as by RFC 2518 8.10.1

                                // - only do this for newly created locks

                                resp.addHeader("Lock-Token", "<opaquelocktoken:" + lockToken + ">");

                        }

                }

                if (lockRequestType == LOCK_REFRESH) {

                }

                // Set the status, then generate the XML response containing

                // the lock information.

                XMLWriter generatedXML = new XMLWriter();

                generatedXML.writeXMLHeader();

                generatedXML.writeElement(null, "prop" + generateNamespaceDeclarations(), XMLWriter.OPENING);

                generatedXML.writeElement(null, "lockdiscovery", XMLWriter.OPENING);

                lock.toXML(generatedXML);

                generatedXML.writeElement(null, "lockdiscovery", XMLWriter.CLOSING);

                generatedXML.writeElement(null, "prop", XMLWriter.CLOSING);

                resp.setStatus(WebdavStatus.SC_OK);

                resp.setContentType("text/xml; charset=UTF-8");

                Writer writer = resp.getWriter();

                writer.write(generatedXML.toString());

                writer.close();

        }

        /**

         * The MOVE method.

         *

         * @param req the HTTP request

         * @param resp the HTTP response

         * @throws IOException if an error occurs while sending the response

         * @throws ServletException

         */

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

                if (isLocked(req)) {

                        resp.sendError(WebdavStatus.SC_LOCKED);

                        return;

                }

                String path = getRelativePath(req);

                if (copyResource(req, resp))

                        deleteResource(path, req, resp, false);

        }

        /**

         * The COPY method.

         *

         * @param req the HTTP request

         * @param resp the HTTP response

         * @throws IOException if an error occurs while sending the response

         * @throws ServletException

         */

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

                copyResource(req, resp);

        }

        /**

         * The MKCOL method.

         *

         * @param req the HTTP request

         * @param resp the HTTP response

         * @throws IOException if an error occurs while sending the response

         * @throws ServletException

         */

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

                if (isLocked(req)) {

                        resp.sendError(WebdavStatus.SC_LOCKED);

                        return;

                }

                final String path = getRelativePath(req);

                if (path.toUpperCase().startsWith("/WEB-INF") || path.toUpperCase().startsWith("/META-INF")) {

                        resp.sendError(WebdavStatus.SC_FORBIDDEN);

                        return;

                }

                final User user = getUser(req);

                boolean exists = true;

                try {

                        getService().getResourceAtPath(user.getId(), path, true);

                } catch (ObjectNotFoundException e) {

                        exists = false;

                } catch (RpcException e) {

                        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, path);

                        return;

                }

                // Can't create a collection if a resource already exists at the given

                // path.

                if (exists) {

                        // Get allowed methods.

                        StringBuffer methodsAllowed;

                        try {

                                methodsAllowed = determineMethodsAllowed(req);

                        } catch (RpcException e) {

                                resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, path);

                                return;

                        }

                        resp.addHeader("Allow", methodsAllowed.toString());

                        resp.sendError(WebdavStatus.SC_METHOD_NOT_ALLOWED);

                        return;

                }

                if (req.getInputStream().available() > 0) {

                        DocumentBuilder documentBuilder = getDocumentBuilder();

                        try {

                                @SuppressWarnings("unused")

                                Document document = documentBuilder.parse(new InputSource(req.getInputStream()));

                                // TODO : Process this request body

                                resp.sendError(WebdavStatus.SC_NOT_IMPLEMENTED);

                                return;

                        } catch (SAXException saxe) {

                                // Parse error - assume invalid content

                                resp.sendError(WebdavStatus.SC_BAD_REQUEST);

                                return;

                        }

                }

                Object parent;

                try {

                        parent = getService().getResourceAtPath(user.getId(), getParentPath(path), true);

                } catch (ObjectNotFoundException e) {

                        resp.sendError(WebdavStatus.SC_CONFLICT, WebdavStatus.getStatusText(WebdavStatus.SC_CONFLICT));

                        return;

                } catch (RpcException e) {

                        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, path);

                        return;

                }

                try {

                        if (parent instanceof FolderDTO) {

                                final FolderDTO folder = (FolderDTO) parent;

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

                                        @Override

                                        public Void call() throws Exception {

                                                getService().createFolder(user.getId(), folder.getId(), getLastElement(path));

                                                return null;

                                        }

                                });

                        } else {

                                resp.sendError(WebdavStatus.SC_FORBIDDEN, WebdavStatus.getStatusText(WebdavStatus.SC_FORBIDDEN));

                                return;

                        }

                } catch (DuplicateNameException e) {

                        // XXX If the existing name is a folder we should be returning

                        // SC_METHOD_NOT_ALLOWED, or even better, just do the createFolder

                        // without checking first and then deal with the exceptions.

                        resp.sendError(WebdavStatus.SC_FORBIDDEN, WebdavStatus.getStatusText(WebdavStatus.SC_FORBIDDEN));

                        return;

                } catch (InsufficientPermissionsException e) {

                        resp.sendError(WebdavStatus.SC_FORBIDDEN, WebdavStatus.getStatusText(WebdavStatus.SC_FORBIDDEN));

                        return;

                } catch (ObjectNotFoundException e) {

                        resp.sendError(WebdavStatus.SC_CONFLICT, WebdavStatus.getStatusText(WebdavStatus.SC_CONFLICT));

                        return;

                } catch (RpcException e) {

                        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, path);

                        return;

                } catch (Exception e) {

                        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, path);

                        return;

                }

                resp.setStatus(WebdavStatus.SC_CREATED);

        }

        /**

         * For a provided path, remove the last element and return the rest, that is

         * the path of the parent folder.

         *

         * @param path the specified path

         * @return the path of the parent folder

         * @throws ObjectNotFoundException if the provided string contains no path

         *             delimiters

         */

        protected String getParentPath(String path) throws ObjectNotFoundException {

                int lastDelimiter = path.lastIndexOf('/');

                if (lastDelimiter == 0)

                        return "/";

                if (lastDelimiter == -1)

                        // No path found.

                        throw new ObjectNotFoundException("There is no parent in the path: " + path);

                else if (lastDelimiter < path.length() - 1)

                        // Return the part before the delimiter.

                        return path.substring(0, lastDelimiter);

                else {

                        // Remove the trailing delimiter and then recurse.

                        String strippedTrail = path.substring(0, lastDelimiter);

                        return getParentPath(strippedTrail);

                }

        }

        /**

         * Get the last element in a path that denotes the file or folder name.

         *

         * @param path the provided path

         * @return the last element in the path

         */

        protected String getLastElement(String path) {

                int lastDelimiter = path.lastIndexOf('/');

                if (lastDelimiter == -1)

                        // No path found.

                        return path;

                else if (lastDelimiter < path.length() - 1)

                        // Return the part after the delimiter.