001    /**
002     * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.webserver;
016    
017    import com.liferay.portal.NoSuchGroupException;
018    import com.liferay.portal.freemarker.FreeMarkerUtil;
019    import com.liferay.portal.kernel.exception.PortalException;
020    import com.liferay.portal.kernel.exception.SystemException;
021    import com.liferay.portal.kernel.freemarker.FreeMarkerContext;
022    import com.liferay.portal.kernel.freemarker.FreeMarkerEngineUtil;
023    import com.liferay.portal.kernel.image.ImageBag;
024    import com.liferay.portal.kernel.image.ImageProcessorUtil;
025    import com.liferay.portal.kernel.log.Log;
026    import com.liferay.portal.kernel.log.LogFactoryUtil;
027    import com.liferay.portal.kernel.repository.RepositoryException;
028    import com.liferay.portal.kernel.repository.model.FileEntry;
029    import com.liferay.portal.kernel.repository.model.FileVersion;
030    import com.liferay.portal.kernel.repository.model.Folder;
031    import com.liferay.portal.kernel.servlet.HttpHeaders;
032    import com.liferay.portal.kernel.servlet.PortalSessionThreadLocal;
033    import com.liferay.portal.kernel.servlet.Range;
034    import com.liferay.portal.kernel.servlet.ServletResponseUtil;
035    import com.liferay.portal.kernel.util.CharPool;
036    import com.liferay.portal.kernel.util.ContentTypes;
037    import com.liferay.portal.kernel.util.FastDateFormatFactoryUtil;
038    import com.liferay.portal.kernel.util.FileUtil;
039    import com.liferay.portal.kernel.util.GetterUtil;
040    import com.liferay.portal.kernel.util.HtmlUtil;
041    import com.liferay.portal.kernel.util.HttpUtil;
042    import com.liferay.portal.kernel.util.MimeTypesUtil;
043    import com.liferay.portal.kernel.util.ParamUtil;
044    import com.liferay.portal.kernel.util.ReleaseInfo;
045    import com.liferay.portal.kernel.util.StringBundler;
046    import com.liferay.portal.kernel.util.StringPool;
047    import com.liferay.portal.kernel.util.StringUtil;
048    import com.liferay.portal.kernel.util.Validator;
049    import com.liferay.portal.kernel.util.Validator_IW;
050    import com.liferay.portal.kernel.webdav.WebDAVUtil;
051    import com.liferay.portal.model.Company;
052    import com.liferay.portal.model.Group;
053    import com.liferay.portal.model.Image;
054    import com.liferay.portal.model.ImageConstants;
055    import com.liferay.portal.model.User;
056    import com.liferay.portal.model.impl.ImageImpl;
057    import com.liferay.portal.security.auth.PrincipalException;
058    import com.liferay.portal.security.auth.PrincipalThreadLocal;
059    import com.liferay.portal.security.permission.PermissionChecker;
060    import com.liferay.portal.security.permission.PermissionCheckerFactoryUtil;
061    import com.liferay.portal.security.permission.PermissionThreadLocal;
062    import com.liferay.portal.service.CompanyLocalServiceUtil;
063    import com.liferay.portal.service.GroupLocalServiceUtil;
064    import com.liferay.portal.service.ImageLocalServiceUtil;
065    import com.liferay.portal.service.ImageServiceUtil;
066    import com.liferay.portal.service.UserLocalServiceUtil;
067    import com.liferay.portal.util.Portal;
068    import com.liferay.portal.util.PortalUtil;
069    import com.liferay.portal.util.PropsValues;
070    import com.liferay.portlet.documentlibrary.NoSuchFileEntryException;
071    import com.liferay.portlet.documentlibrary.NoSuchFolderException;
072    import com.liferay.portlet.documentlibrary.model.DLFileEntry;
073    import com.liferay.portlet.documentlibrary.model.DLFileShortcut;
074    import com.liferay.portlet.documentlibrary.model.DLFolderConstants;
075    import com.liferay.portlet.documentlibrary.service.DLAppLocalServiceUtil;
076    import com.liferay.portlet.documentlibrary.service.DLAppServiceUtil;
077    import com.liferay.portlet.documentlibrary.service.DLFileEntryServiceUtil;
078    import com.liferay.portlet.documentlibrary.util.AudioProcessor;
079    import com.liferay.portlet.documentlibrary.util.DLUtil;
080    import com.liferay.portlet.documentlibrary.util.DocumentConversionUtil;
081    import com.liferay.portlet.documentlibrary.util.ImageProcessor;
082    import com.liferay.portlet.documentlibrary.util.PDFProcessor;
083    import com.liferay.portlet.documentlibrary.util.VideoProcessor;
084    
085    import java.awt.image.RenderedImage;
086    
087    import java.io.File;
088    import java.io.FileInputStream;
089    import java.io.IOException;
090    import java.io.InputStream;
091    
092    import java.text.Format;
093    
094    import java.util.ArrayList;
095    import java.util.Date;
096    import java.util.List;
097    
098    import javax.servlet.ServletConfig;
099    import javax.servlet.ServletException;
100    import javax.servlet.http.HttpServlet;
101    import javax.servlet.http.HttpServletRequest;
102    import javax.servlet.http.HttpServletResponse;
103    import javax.servlet.http.HttpSession;
104    
105    /**
106     * @author Alexander Chow
107     * @author Brian Wing Shun Chan
108     */
109    public class WebServerServlet extends HttpServlet {
110    
111            /**
112             * @see com.liferay.portal.servlet.filters.virtualhost.VirtualHostFilter
113             */
114            public static boolean hasFiles(HttpServletRequest request) {
115                    try {
116    
117                            // Do not use permission checking since this may be called from
118                            // other contexts that are also managing the principal
119    
120                            User user = _getUser(request);
121    
122                            String path = HttpUtil.fixPath(request.getPathInfo());
123    
124                            String[] pathArray = StringUtil.split(path, CharPool.SLASH);
125    
126                            if (pathArray.length == 0) {
127                                    return true;
128                            }
129                            else if (Validator.isNumber(pathArray[0])) {
130                                    _checkFileEntry(pathArray);
131                            }
132                            else {
133                                    long groupId = _getGroupId(user.getCompanyId(), pathArray[0]);
134                                    long folderId = DLFolderConstants.DEFAULT_PARENT_FOLDER_ID;
135    
136                                    for (int i = 1; i < pathArray.length; i++) {
137                                            try {
138                                                    Folder folder = DLAppLocalServiceUtil.getFolder(
139                                                            groupId, folderId, pathArray[i]);
140    
141                                                    folderId = folder.getFolderId();
142                                            }
143                                            catch (NoSuchFolderException nsfe) {
144                                                    if (i != pathArray.length - 1) {
145                                                            return false;
146                                                    }
147    
148                                                    pathArray = new String[] {
149                                                            String.valueOf(groupId), String.valueOf(folderId),
150                                                            pathArray[i]
151                                                    };
152    
153                                                    _checkFileEntry(pathArray);
154                                            }
155                                    }
156                            }
157                    }
158                    catch (Exception e) {
159                            return false;
160                    }
161    
162                    return true;
163            }
164    
165            @Override
166            public void init(ServletConfig servletConfig) throws ServletException {
167                    super.init(servletConfig);
168    
169                    _lastModified = GetterUtil.getBoolean(
170                            servletConfig.getInitParameter("last_modified"), true);
171            }
172    
173            @Override
174            public void service(
175                            HttpServletRequest request, HttpServletResponse response)
176                    throws IOException, ServletException {
177    
178                    User user = null;
179    
180                    try {
181                            user = _getUser(request);
182    
183                            PrincipalThreadLocal.setName(user.getUserId());
184                            PrincipalThreadLocal.setPassword(
185                                    PortalUtil.getUserPassword(request));
186    
187                            PermissionChecker permissionChecker =
188                                    PermissionCheckerFactoryUtil.create(user, true);
189    
190                            PermissionThreadLocal.setPermissionChecker(permissionChecker);
191    
192                            if (_lastModified) {
193                                    long lastModified = getLastModified(request);
194    
195                                    if (lastModified > 0) {
196                                            long ifModifiedSince = request.getDateHeader(
197                                                    HttpHeaders.IF_MODIFIED_SINCE);
198    
199                                            if ((ifModifiedSince > 0) &&
200                                                    (ifModifiedSince == lastModified)) {
201    
202                                                    response.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
203    
204                                                    return;
205                                            }
206                                    }
207    
208                                    if (lastModified > 0) {
209                                            response.setDateHeader(
210                                                    HttpHeaders.LAST_MODIFIED, lastModified);
211                                    }
212                            }
213    
214                            String path = HttpUtil.fixPath(request.getPathInfo());
215                            String[] pathArray = StringUtil.split(path, CharPool.SLASH);
216    
217                            if (pathArray.length == 0) {
218                                    sendGroups(
219                                            response, user,
220                                            request.getServletPath() + StringPool.SLASH + path);
221                            }
222                            else {
223                                    if (Validator.isNumber(pathArray[0])) {
224                                            sendFile(request, response, user, pathArray);
225                                    }
226                                    else {
227                                            if (isLegacyImageGalleryImageId(request, response)) {
228                                                    return;
229                                            }
230    
231                                            Image image = getImage(request, true);
232    
233                                            if (image != null) {
234                                                    writeImage(image, request, response);
235                                            }
236                                            else {
237                                                    sendDocumentLibrary(
238                                                            request, response, user,
239                                                            request.getServletPath() + StringPool.SLASH + path,
240                                                            pathArray);
241                                            }
242                                    }
243                            }
244                    }
245                    catch (NoSuchFileEntryException nsfee) {
246                            PortalUtil.sendError(
247                                    HttpServletResponse.SC_NOT_FOUND, nsfee, request, response);
248                    }
249                    catch (PrincipalException pe) {
250                            processPrincipalException(pe, user, request, response);
251                    }
252                    catch (Exception e) {
253                            PortalUtil.sendError(e, request, response);
254                    }
255            }
256    
257            protected boolean isLegacyImageGalleryImageId(
258                    HttpServletRequest request, HttpServletResponse response) {
259    
260                    try {
261                            long imageId = getImageId(request);
262    
263                            if (imageId == 0) {
264                                    return false;
265                            }
266    
267                            DLFileEntry dlFileEntry =
268                                    DLFileEntryServiceUtil.fetchFileEntryByImageId(imageId);
269    
270                            if (dlFileEntry == null) {
271                                    return false;
272                            }
273    
274                            StringBundler sb = new StringBundler(9);
275    
276                            sb.append("/documents/");
277                            sb.append(dlFileEntry.getGroupId());
278                            sb.append(StringPool.SLASH);
279                            sb.append(dlFileEntry.getFolderId());
280                            sb.append(StringPool.SLASH);
281                            sb.append(
282                                    HttpUtil.encodeURL(
283                                            HtmlUtil.unescape(dlFileEntry.getTitle()), true));
284                            sb.append("?version=");
285                            sb.append(dlFileEntry.getVersion());
286    
287                            if (imageId == dlFileEntry.getSmallImageId()) {
288                                    sb.append("&imageThumbnail=1");
289                            }
290                            else if (imageId == dlFileEntry.getSmallImageId()) {
291                                    sb.append("&imageThumbnail=2");
292                            }
293                            else if (imageId == dlFileEntry.getSmallImageId()) {
294                                    sb.append("&imageThumbnail=3");
295                            }
296    
297                            response.setHeader(HttpHeaders.LOCATION, sb.toString());
298                            response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY);
299    
300                            return true;
301                    }
302                    catch (Exception e) {
303                    }
304    
305                    return false;
306            }
307    
308            protected Image getDefaultImage(HttpServletRequest request, long imageId) {
309                    String path = GetterUtil.getString(request.getPathInfo());
310    
311                    if (path.startsWith("/company_logo") ||
312                            path.startsWith("/layout_set_logo") || path.startsWith("/logo")) {
313    
314                            return ImageLocalServiceUtil.getDefaultCompanyLogo();
315                    }
316                    else if (path.startsWith("/organization_logo")) {
317                            return ImageLocalServiceUtil.getDefaultOrganizationLogo();
318                    }
319                    else if (path.startsWith("/user_female_portrait")) {
320                            return ImageLocalServiceUtil.getDefaultUserFemalePortrait();
321                    }
322                    else if (path.startsWith("/user_male_portrait")) {
323                            return ImageLocalServiceUtil.getDefaultUserMalePortrait();
324                    }
325                    else if (path.startsWith("/user_portrait")) {
326                            return ImageLocalServiceUtil.getDefaultUserMalePortrait();
327                    }
328                    else {
329                            return null;
330                    }
331            }
332    
333            protected FileEntry getFileEntry(String[] pathArray) throws Exception {
334                    if (pathArray.length == 1) {
335                            long dlFileShortcutId = GetterUtil.getLong(pathArray[0]);
336    
337                            DLFileShortcut dlFileShortcut = DLAppServiceUtil.getFileShortcut(
338                                    dlFileShortcutId);
339    
340                            return DLAppServiceUtil.getFileEntry(
341                                    dlFileShortcut.getToFileEntryId());
342                    }
343                    else if (pathArray.length == 2) {
344                            long groupId = GetterUtil.getLong(pathArray[0]);
345    
346                            return DLAppServiceUtil.getFileEntryByUuidAndGroupId(
347                                    pathArray[1], groupId);
348                    }
349                    else {
350                            long groupId = GetterUtil.getLong(pathArray[0]);
351                            long folderId = GetterUtil.getLong(pathArray[1]);
352    
353                            String fileName = pathArray[2];
354    
355                            if (fileName.contains(StringPool.QUESTION)) {
356                                    fileName = fileName.substring(
357                                            0, fileName.indexOf(StringPool.QUESTION));
358                            }
359    
360                            return DLAppServiceUtil.getFileEntry(groupId, folderId, fileName);
361                    }
362            }
363    
364            protected Image getImage(HttpServletRequest request, boolean getDefault)
365                    throws PortalException, SystemException {
366    
367                    Image image = null;
368    
369                    long imageId = getImageId(request);
370    
371                    if (imageId > 0) {
372                            image = ImageServiceUtil.getImage(imageId);
373    
374                            String path = GetterUtil.getString(request.getPathInfo());
375    
376                            if (path.startsWith("/user_female_portrait") ||
377                                    path.startsWith("/user_male_portrait") ||
378                                    path.startsWith("/user_portrait")) {
379    
380                                    image = getUserPortraitImageResized(image, imageId);
381                            }
382                    }
383                    else {
384                            String uuid = ParamUtil.getString(request, "uuid");
385                            long groupId = ParamUtil.getLong(request, "groupId");
386                            boolean igSmallImage = ParamUtil.getBoolean(
387                                    request, "igSmallImage");
388    
389                            if (Validator.isNotNull(uuid) && (groupId > 0)) {
390                                    try {
391                                            FileEntry fileEntry =
392                                                    DLAppServiceUtil.getFileEntryByUuidAndGroupId(
393                                                            uuid, groupId);
394    
395                                            image = convertFileEntry(igSmallImage, fileEntry);
396                                    }
397                                    catch (Exception e) {
398                                    }
399                            }
400                    }
401    
402                    if (getDefault) {
403                            if (image == null) {
404                                    if (_log.isWarnEnabled()) {
405                                            _log.warn("Get a default image for " + imageId);
406                                    }
407    
408                                    image = getDefaultImage(request, imageId);
409                            }
410                    }
411    
412                    return image;
413            }
414    
415            protected Image convertFileEntry(boolean smallImage, FileEntry fileEntry)
416                    throws PortalException, SystemException {
417    
418                    try {
419                            Image image = new ImageImpl();
420    
421                            image.setModifiedDate(fileEntry.getModifiedDate());
422    
423                            InputStream is = null;
424    
425                            if (smallImage) {
426                                    is = ImageProcessor.getThumbnailAsStream(
427                                            fileEntry.getFileVersion());
428                            }
429                            else {
430                                    is = fileEntry.getContentStream();
431                            }
432    
433                            byte[] bytes = FileUtil.getBytes(is);
434    
435                            image.setTextObj(bytes);
436    
437                            image.setType(fileEntry.getExtension());
438    
439                            return image;
440                    }
441                    catch (PortalException pe) {
442                            throw pe;
443                    }
444                    catch (SystemException se) {
445                            throw se;
446                    }
447                    catch (Exception e) {
448                            throw new SystemException(e);
449                    }
450            }
451    
452            protected byte[] getImageBytes(HttpServletRequest request, Image image) {
453                    try {
454                            if (!PropsValues.IMAGE_AUTO_SCALE) {
455                                    return image.getTextObj();
456                            }
457    
458                            ImageBag imageBag = null;
459    
460                            if (image.getImageId() == 0) {
461                                    imageBag = ImageProcessorUtil.read(image.getTextObj());
462    
463                                    RenderedImage renderedImage = imageBag.getRenderedImage();
464    
465                                    image.setHeight(renderedImage.getHeight());
466                                    image.setWidth(renderedImage.getWidth());
467                            }
468    
469                            int height = ParamUtil.getInteger(
470                                    request, "height", image.getHeight());
471                            int width = ParamUtil.getInteger(
472                                    request, "width", image.getWidth());
473    
474                            if ((height >= image.getHeight()) && (width >= image.getWidth())) {
475                                    return image.getTextObj();
476                            }
477    
478                            if (image.getImageId() != 0) {
479                                    imageBag = ImageProcessorUtil.read(image.getTextObj());
480                            }
481    
482                            RenderedImage renderedImage = ImageProcessorUtil.scale(
483                                    imageBag.getRenderedImage(), height, width);
484    
485                            return ImageProcessorUtil.getBytes(
486                                    renderedImage, imageBag.getType());
487                    }
488                    catch (Exception e) {
489                            if (_log.isWarnEnabled()) {
490                                    _log.warn("Error scaling image " + image.getImageId(), e);
491                            }
492                    }
493    
494                    return image.getTextObj();
495            }
496    
497            protected long getImageId(HttpServletRequest request) {
498    
499                    // The image id may be passed in as image_id, img_id, or i_id
500    
501                    long imageId = ParamUtil.getLong(request, "image_id");
502    
503                    if (imageId <= 0) {
504                            imageId = ParamUtil.getLong(request, "img_id");
505                    }
506    
507                    if (imageId <= 0) {
508                            imageId = ParamUtil.getLong(request, "i_id");
509                    }
510    
511                    if (imageId <= 0) {
512                            long companyId = ParamUtil.getLong(request, "companyId");
513                            String screenName = ParamUtil.getString(request, "screenName");
514    
515                            try {
516                                    if ((companyId > 0) && Validator.isNotNull(screenName)) {
517                                            User user = UserLocalServiceUtil.getUserByScreenName(
518                                                    companyId, screenName);
519    
520                                            imageId = user.getPortraitId();
521                                    }
522                            }
523                            catch (Exception e) {
524                            }
525                    }
526    
527                    return imageId;
528            }
529    
530            @Override
531            protected long getLastModified(HttpServletRequest request) {
532                    try {
533                            Date modifiedDate = null;
534    
535                            Image image = getImage(request, true);
536    
537                            if (image != null) {
538                                    modifiedDate = image.getModifiedDate();
539                            }
540                            else {
541                                    String path = HttpUtil.fixPath(request.getPathInfo());
542    
543                                    String[] pathArray = StringUtil.split(path, CharPool.SLASH);
544    
545                                    if (pathArray.length == 0) {
546                                            return -1;
547                                    }
548    
549                                    if (pathArray[0].equals("language")) {
550                                            return -1;
551                                    }
552    
553                                    FileEntry fileEntry = null;
554    
555                                    try {
556                                            fileEntry = getFileEntry(pathArray);
557                                    }
558                                    catch (Exception e) {
559                                    }
560    
561                                    if (fileEntry == null) {
562                                            return -1;
563                                    }
564                                    else {
565                                            String version = ParamUtil.getString(request, "version");
566    
567                                            if (Validator.isNotNull(version)) {
568                                                    FileVersion fileVersion = fileEntry.getFileVersion(
569                                                            version);
570    
571                                                    modifiedDate = fileVersion.getModifiedDate();
572                                            }
573                                            else {
574                                                    modifiedDate = fileEntry.getModifiedDate();
575                                            }
576                                    }
577                            }
578    
579                            if (modifiedDate == null) {
580                                    modifiedDate = PortalUtil.getUptime();
581                            }
582    
583                            // Round down and remove milliseconds
584    
585                            return (modifiedDate.getTime() / 1000) * 1000;
586                    }
587                    catch (PrincipalException pe) {
588                            if (_log.isWarnEnabled()) {
589                                    _log.warn(pe, pe);
590                            }
591                    }
592                    catch (Exception e) {
593                            _log.error(e, e);
594                    }
595    
596                    return -1;
597            }
598    
599            protected Image getUserPortraitImageResized(Image image, long imageId)
600                    throws PortalException, SystemException {
601    
602                    if (image == null) {
603                            return null;
604                    }
605    
606                    if ((image.getHeight() > PropsValues.USERS_IMAGE_MAX_HEIGHT) ||
607                            (image.getWidth() > PropsValues.USERS_IMAGE_MAX_WIDTH)) {
608    
609                            User user = UserLocalServiceUtil.getUserByPortraitId(imageId);
610    
611                            UserLocalServiceUtil.updatePortrait(
612                                    user.getUserId(), image.getTextObj());
613    
614                            return ImageLocalServiceUtil.getImage(imageId);
615                    }
616    
617                    return image;
618            }
619    
620            protected void processPrincipalException(
621                            Throwable t, User user, HttpServletRequest request,
622                            HttpServletResponse response)
623                    throws IOException, ServletException {
624    
625                    if (!user.isDefaultUser()) {
626                            PortalUtil.sendError(
627                                    HttpServletResponse.SC_UNAUTHORIZED, (Exception)t, request,
628                                    response);
629    
630                            return;
631                    }
632    
633                    String redirect =
634                            request.getContextPath() + Portal.PATH_MAIN + "/portal/login";
635    
636                    String currentURL = PortalUtil.getCurrentURL(request);
637    
638                    redirect = HttpUtil.addParameter(redirect, "redirect", currentURL);
639    
640                    response.sendRedirect(redirect);
641            }
642    
643            protected void sendDocumentLibrary(
644                            HttpServletRequest request, HttpServletResponse response, User user,
645                            String path, String[] pathArray)
646                    throws Exception {
647    
648                    if (!PropsValues.WEB_SERVER_SERVLET_DIRECTORY_INDEXING_ENABLED) {
649                            response.setStatus(HttpServletResponse.SC_FORBIDDEN);
650    
651                            return;
652                    }
653    
654                    long groupId = _getGroupId(user.getCompanyId(), pathArray[0]);
655                    long folderId = DLFolderConstants.DEFAULT_PARENT_FOLDER_ID;
656    
657                    for (int i = 1; i < pathArray.length; i++) {
658                            String name = pathArray[i];
659    
660                            try {
661                                    Folder folder = DLAppServiceUtil.getFolder(
662                                            groupId, folderId, name);
663    
664                                    folderId = folder.getFolderId();
665                            }
666                            catch (NoSuchFolderException nsfe) {
667                                    if (i != pathArray.length - 1) {
668                                            throw nsfe;
669                                    }
670    
671                                    String title = name;
672    
673                                    sendFile(response, user, groupId, folderId, title);
674    
675                                    return;
676                            }
677                    }
678    
679                    try {
680                            sendFile(response, user, groupId, folderId, "index.html");
681    
682                            return;
683                    }
684                    catch (Exception e) {
685                            if ((e instanceof NoSuchFileEntryException) ||
686                                    (e instanceof PrincipalException)) {
687    
688                                    try {
689                                            sendFile(response, user, groupId, folderId, "index.htm");
690    
691                                            return;
692                                    }
693                                    catch (NoSuchFileEntryException nsfee) {
694                                    }
695                                    catch (PrincipalException pe) {
696                                    }
697                            }
698                            else {
699                                    throw e;
700                            }
701                    }
702    
703                    List<WebServerEntry> webServerEntries = new ArrayList<WebServerEntry>();
704    
705                    webServerEntries.add(new WebServerEntry(path, "../"));
706    
707                    List<Folder> folders = DLAppServiceUtil.getFolders(groupId, folderId);
708    
709                    for (Folder folder : folders) {
710                            WebServerEntry webServerEntry = new WebServerEntry(
711                                    path, folder.getName() + StringPool.SLASH,
712                                    folder.getCreateDate(), folder.getModifiedDate(),
713                                    folder.getDescription(), 0);
714    
715                            webServerEntries.add(webServerEntry);
716                    }
717    
718                    List<FileEntry> fileEntries = DLAppServiceUtil.getFileEntries(
719                            groupId, folderId);
720    
721                    for (FileEntry fileEntry : fileEntries) {
722                            WebServerEntry webServerEntry = new WebServerEntry(
723                                    path, fileEntry.getTitle(), fileEntry.getCreateDate(),
724                                    fileEntry.getModifiedDate(), fileEntry.getDescription(),
725                                    fileEntry.getSize());
726    
727                            webServerEntries.add(webServerEntry);
728                    }
729    
730                    sendHTML(response, path, webServerEntries);
731            }
732    
733            protected void sendFile(
734                            HttpServletRequest request, HttpServletResponse response,
735                            User user, String[] pathArray)
736                    throws Exception {
737    
738                    FileEntry fileEntry = getFileEntry(pathArray);
739    
740                    if (fileEntry == null) {
741                            throw new NoSuchFileEntryException();
742                    }
743    
744                    String version = ParamUtil.getString(request, "version");
745    
746                    if (Validator.isNull(version)) {
747                            if (Validator.isNotNull(fileEntry.getVersion())) {
748                                    version = fileEntry.getVersion();
749                            }
750                    }
751    
752                    String tempFileId = DLUtil.getTempFileId(
753                            fileEntry.getFileEntryId(), version);
754    
755                    FileVersion fileVersion = fileEntry.getFileVersion(version);
756    
757                    String fileName = fileVersion.getTitle();
758    
759                    String extension = fileVersion.getExtension();
760    
761                    if (!fileName.endsWith(StringPool.PERIOD + extension)) {
762                            fileName += StringPool.PERIOD + extension;
763                    }
764    
765                    boolean converted = false;
766    
767                    String targetExtension = ParamUtil.getString(
768                            request, "targetExtension");
769                    int imageThumbnail = ParamUtil.getInteger(request, "imageThumbnail");
770                    boolean documentThumbnail = ParamUtil.getBoolean(
771                            request, "documentThumbnail");
772                    int previewFileIndex = ParamUtil.getInteger(
773                            request, "previewFileIndex");
774                    boolean audioPreview = ParamUtil.getBoolean(request, "audioPreview");
775                    boolean videoPreview = ParamUtil.getBoolean(request, "videoPreview");
776                    boolean videoThumbnail = ParamUtil.getBoolean(
777                            request, "videoThumbnail");
778    
779                    InputStream inputStream = null;
780                    long contentLength = 0;
781    
782                    if ((imageThumbnail > 0) && (imageThumbnail < 3)) {
783                            fileName = FileUtil.stripExtension(fileName).concat(
784                                    StringPool.PERIOD).concat(fileVersion.getExtension());
785    
786                            if (imageThumbnail == 1) {
787                                    inputStream = ImageProcessor.getThumbnailAsStream(fileVersion);
788                                    contentLength = ImageProcessor.getThumbnailFileSize(
789                                            fileVersion);
790                            }
791                            else if (imageThumbnail == 2) {
792                                    inputStream = ImageProcessor.getCustom1AsStream(fileVersion);
793                                    contentLength = ImageProcessor.getCustom1FileSize(fileVersion);
794                            }
795                            else if (imageThumbnail == 3) {
796                                    inputStream = ImageProcessor.getCustom2AsStream(fileVersion);
797                                    contentLength = ImageProcessor.getCustom2FileSize(fileVersion);
798                            }
799    
800                            converted = true;
801                    }
802                    else if (documentThumbnail) {
803                            fileName = FileUtil.stripExtension(fileName).concat(
804                                    StringPool.PERIOD).concat(PDFProcessor.THUMBNAIL_TYPE);
805                            inputStream = PDFProcessor.getThumbnailAsStream(fileVersion);
806                            contentLength = PDFProcessor.getThumbnailFileSize(fileVersion);
807    
808                            converted = true;
809                    }
810                    else if (previewFileIndex > 0) {
811                            fileName = FileUtil.stripExtension(fileName).concat(
812                                    StringPool.PERIOD).concat(PDFProcessor.PREVIEW_TYPE);
813                            inputStream = PDFProcessor.getPreviewAsStream(
814                                    fileVersion, previewFileIndex);
815                            contentLength = PDFProcessor.getPreviewFileSize(
816                                    fileVersion, previewFileIndex);
817    
818                            converted = true;
819                    }
820                    else if (audioPreview) {
821                            fileName = FileUtil.stripExtension(fileName).concat(
822                                    StringPool.PERIOD).concat(AudioProcessor.PREVIEW_TYPE);
823                            inputStream = AudioProcessor.getPreviewAsStream(fileVersion);
824                            contentLength = AudioProcessor.getPreviewFileSize(fileVersion);
825    
826                            converted = true;
827                    }
828                    else if (videoPreview) {
829                            String type = ParamUtil.getString(request, "type");
830    
831                            fileName = FileUtil.stripExtension(fileName).concat(
832                                    StringPool.PERIOD).concat(type);
833                            inputStream = VideoProcessor.getPreviewAsStream(fileVersion, type);
834                            contentLength = VideoProcessor.getPreviewFileSize(
835                                    fileVersion, type);
836    
837                            response.setHeader(
838                                    HttpHeaders.ACCEPT_RANGES,
839                                    HttpHeaders.ACCEPT_RANGES_BYTES_VALUE);
840    
841                            List<Range> ranges = null;
842    
843                            try {
844                                    ranges = ServletResponseUtil.getRanges(
845                                            request, response, contentLength);
846                            }
847                            catch (IOException ioe) {
848                                    if (_log.isErrorEnabled()) {
849                                            _log.error(ioe);
850                                    }
851    
852                                    response.setHeader(
853                                            HttpHeaders.CONTENT_RANGE, "bytes */" + contentLength);
854    
855                                    response.sendError(
856                                            HttpServletResponse.SC_REQUESTED_RANGE_NOT_SATISFIABLE);
857    
858                                    return;
859                            }
860    
861                            if ((ranges != null) && (ranges.size() > 0)) {
862                                    if (_log.isDebugEnabled()) {
863                                            _log.debug("Video range requested");
864                                    }
865    
866                                    String contentType = MimeTypesUtil.getContentType(fileName);
867    
868                                    ServletResponseUtil.write(
869                                            request, response, fileName, ranges, inputStream,
870                                            contentLength, contentType);
871    
872                                    return;
873                            }
874    
875                            converted = true;
876                    }
877                    else if (videoThumbnail) {
878                            fileName = FileUtil.stripExtension(fileName).concat(
879                                    StringPool.PERIOD).concat(VideoProcessor.THUMBNAIL_TYPE);
880                            inputStream = VideoProcessor.getThumbnailAsStream(fileVersion);
881                            contentLength = VideoProcessor.getThumbnailFileSize(fileVersion);
882    
883                            converted = true;
884                    }
885                    else {
886                            inputStream = fileVersion.getContentStream(true);
887                            contentLength = fileVersion.getSize();
888    
889                            if (Validator.isNotNull(targetExtension)) {
890                                    File convertedFile = DocumentConversionUtil.convert(
891                                            tempFileId, inputStream, extension, targetExtension);
892    
893                                    if (convertedFile != null) {
894                                            fileName = FileUtil.stripExtension(fileName).concat(
895                                                    StringPool.PERIOD).concat(targetExtension);
896                                            inputStream = new FileInputStream(convertedFile);
897                                            contentLength = convertedFile.length();
898    
899                                            converted = true;
900                                    }
901                            }
902                    }
903    
904                    String contentType = null;
905    
906                    if (converted) {
907                            contentType = MimeTypesUtil.getContentType(fileName);
908                    }
909                    else {
910                            contentType = fileVersion.getMimeType();
911                    }
912    
913                    ServletResponseUtil.sendFile(
914                            request, response, fileName, inputStream, contentLength,
915                            contentType);
916            }
917    
918            protected void sendFile(
919                            HttpServletResponse response, User user, long groupId,
920                            long folderId, String title)
921                    throws Exception {
922    
923                    FileEntry fileEntry = DLAppServiceUtil.getFileEntry(
924                            groupId, folderId, title);
925    
926                    String contentType = fileEntry.getMimeType();
927    
928                    response.setContentType(contentType);
929    
930                    InputStream inputStream = fileEntry.getContentStream();
931    
932                    ServletResponseUtil.write(response, inputStream);
933            }
934    
935            protected void sendGroups(
936                            HttpServletResponse response, User user, String path)
937                    throws Exception {
938    
939                    if (!PropsValues.WEB_SERVER_SERVLET_DIRECTORY_INDEXING_ENABLED) {
940                            response.setStatus(HttpServletResponse.SC_FORBIDDEN);
941    
942                            return;
943                    }
944    
945                    List<WebServerEntry> webServerEntries = new ArrayList<WebServerEntry>();
946    
947                    List<Group> groups = WebDAVUtil.getGroups(user);
948    
949                    for (Group group : groups) {
950                            String name = HttpUtil.fixPath(group.getFriendlyURL());
951    
952                            WebServerEntry webServerEntry = new WebServerEntry(
953                                    path, name + StringPool.SLASH, null, null,
954                                    group.getDescription(), 0);
955    
956                            webServerEntries.add(webServerEntry);
957                    }
958    
959                    sendHTML(response, path, webServerEntries);
960            }
961    
962            protected void sendHTML(
963                            HttpServletResponse response, String path,
964                            List<WebServerEntry> webServerEntries)
965                    throws Exception {
966    
967                    FreeMarkerContext freeMarkerContext =
968                            FreeMarkerEngineUtil.getWrappedRestrictedToolsContext();
969    
970                    freeMarkerContext.put("dateFormat", _dateFormat);
971                    freeMarkerContext.put("entries", webServerEntries);
972                    freeMarkerContext.put("path", HttpUtil.encodePath(path));
973                    freeMarkerContext.put("serverInfo", ReleaseInfo.getServerInfo());
974                    freeMarkerContext.put("validator", Validator_IW.getInstance());
975    
976                    String html = FreeMarkerUtil.process(_TPL_TEMPLATE, freeMarkerContext);
977    
978                    response.setContentType(ContentTypes.TEXT_HTML_UTF8);
979    
980                    ServletResponseUtil.write(response, html);
981            }
982    
983            protected void writeImage(
984                    Image image, HttpServletRequest request, HttpServletResponse response) {
985    
986                    if (image == null) {
987                            return;
988                    }
989    
990                    String contentType = null;
991    
992                    String type = image.getType();
993    
994                    if (!type.equals(ImageConstants.TYPE_NOT_AVAILABLE)) {
995                            contentType = MimeTypesUtil.getContentType("A." + type);
996    
997                            response.setContentType(contentType);
998                    }
999    
1000                    String fileName = ParamUtil.getString(request, "fileName");
1001    
1002                    try {
1003                            byte[] bytes = getImageBytes(request, image);
1004    
1005                            if (Validator.isNotNull(fileName)) {
1006                                    ServletResponseUtil.sendFile(
1007                                            request, response, fileName, bytes, contentType);
1008                            }
1009                            else {
1010                                    ServletResponseUtil.write(response, bytes);
1011                            }
1012                    }
1013                    catch (Exception e) {
1014                            if (_log.isWarnEnabled()) {
1015                                    _log.warn(e, e);
1016                            }
1017                    }
1018            }
1019    
1020            private static void _checkFileEntry(String[] pathArray)
1021                    throws Exception {
1022    
1023                    if (pathArray.length == 1) {
1024                            long dlFileShortcutId = GetterUtil.getLong(pathArray[0]);
1025    
1026                            DLFileShortcut dlFileShortcut =
1027                                    DLAppLocalServiceUtil.getFileShortcut(dlFileShortcutId);
1028    
1029                            DLAppLocalServiceUtil.getFileEntry(
1030                                    dlFileShortcut.getToFileEntryId());
1031                    }
1032                    else if (pathArray.length == 2) {
1033    
1034                            // Unable to check with UUID because of multiple repositories
1035    
1036                    }
1037                    else {
1038                            long groupId = GetterUtil.getLong(pathArray[0]);
1039                            long folderId = GetterUtil.getLong(pathArray[1]);
1040                            String fileName = pathArray[2];
1041    
1042                            try {
1043                                    DLAppLocalServiceUtil.getFileEntry(groupId, folderId, fileName);
1044                            }
1045                            catch (RepositoryException re) {
1046                            }
1047                    }
1048            }
1049    
1050            private static long _getGroupId(long companyId, String name)
1051                    throws Exception {
1052    
1053                    try {
1054                            Group group = GroupLocalServiceUtil.getFriendlyURLGroup(
1055                                    companyId, StringPool.SLASH + name);
1056    
1057                            return group.getGroupId();
1058                    }
1059                    catch (NoSuchGroupException nsge) {
1060                    }
1061    
1062                    User user = UserLocalServiceUtil.getUserByScreenName(companyId, name);
1063    
1064                    Group group = user.getGroup();
1065    
1066                    return group.getGroupId();
1067            }
1068    
1069            private static User _getUser(HttpServletRequest request) throws Exception {
1070                    HttpSession session = request.getSession();
1071    
1072                    if (PortalSessionThreadLocal.getHttpSession() == null) {
1073                            PortalSessionThreadLocal.setHttpSession(session);
1074                    }
1075    
1076                    User user = PortalUtil.getUser(request);
1077    
1078                    if (user != null) {
1079                            return user;
1080                    }
1081    
1082                    String userIdString = (String)session.getAttribute("j_username");
1083                    String password = (String)session.getAttribute("j_password");
1084    
1085                    if ((userIdString != null) && (password != null)) {
1086                            long userId = GetterUtil.getLong(userIdString);
1087    
1088                            user = UserLocalServiceUtil.getUser(userId);
1089                    }
1090                    else {
1091                            long companyId = PortalUtil.getCompanyId(request);
1092    
1093                            Company company = CompanyLocalServiceUtil.getCompany(companyId);
1094    
1095                            user = company.getDefaultUser();
1096                    }
1097    
1098                    return user;
1099            }
1100    
1101            private static final String _DATE_FORMAT_PATTERN = "d MMM yyyy HH:mm z";
1102    
1103            private static final String _TPL_TEMPLATE =
1104                    "com/liferay/portal/webserver/dependencies/template.ftl";
1105    
1106            private static Format _dateFormat =
1107                    FastDateFormatFactoryUtil.getSimpleDateFormat(_DATE_FORMAT_PATTERN);
1108    
1109            private static Log _log = LogFactoryUtil.getLog(WebServerServlet.class);
1110    
1111            private boolean _lastModified = true;
1112    
1113    }