content: /*
   * This library is part of OpenCms -
   * the Open Source Content Management System
   *
   * Copyright (c) Alkacon Software GmbH & Co. KG (https://www.alkacon.com)
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
   * This library 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
   * Lesser General Public License for more details.
   *
   * For further information about Alkacon Software, please see the
   * company website: https://www.alkacon.com
   *
   * For further information about OpenCms, please see the
   * project website: https://www.opencms.org
   *
   * You should have received a copy of the GNU Lesser General Public
   * License along with this library; if not, write to the Free Software
   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
  package org.opencms.main;
  
  import org.opencms.util.CmsStringUtil;
  
  import java.io.FileNotFoundException;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.net.URI;
  import java.net.URL;
  import java.net.URLConnection;
  
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  import org.apache.commons.logging.Log;
  
  /**
   * Handles the requests for static resources located in the classpath.<p>
   */
  public class CmsStaticResourceHandler implements I_CmsRequestHandler {
  
      /** The handler name. */
      public static final String HANDLER_NAME = "Static";
  
      /** The static resource prefix '/handleStatic'. */
      public static final String STATIC_RESOURCE_PREFIX = OpenCmsServlet.HANDLE_PATH + HANDLER_NAME;
  
      /** The default output buffer size. */
      private static final int DEFAULT_BUFFER_SIZE = 32 * 1024;
  
      /** Default cache lifetime in seconds. */
      private static final int DEFAULT_CACHE_TIME = 3600;
  
      /** The handler names. */
      private static final String[] HANDLER_NAMES = new String[] {HANDLER_NAME};
  
      /** The log object for this class. */
      private static final Log LOG = CmsLog.getLog(CmsStaticResourceHandler.class);
  
      /** The regular expression to remove the static resource path prefix. */
      private static String m_removePrefixRegex;
  
      /** The regular expression to identify static resource paths. */
      private static String m_staticResourceRegex;
  
      /** The opencms path prefix for static resources. */
      private static final String OPENCMS_PATH_PREFIX = "OPENCMS/";
  
      /**
       * Returns the context for static resources served from the class path, e.g. "/opencms/handleStatic/v5976v".<p>
       *
       * @param opencmsContext the OpenCms context
       * @param opencmsVersion the OpenCms version
       *
       * @return the static resource context
       */
      public static String getStaticResourceContext(String opencmsContext, String opencmsVersion) {
  
          return opencmsContext + STATIC_RESOURCE_PREFIX + "/v" + opencmsVersion.hashCode() + "v";
      }
  
      /**
       * Returns the URL to a static resource.<p>
       *
       * @param resourcePath the static resource path
       *
       * @return the resource URL
       */
      public static URL getStaticResourceURL(String resourcePath) {
  
          URL resourceURL = null;
          if (isStaticResourceUri(resourcePath)) {
              String path = removeStaticResourcePrefix(resourcePath);
              path = CmsStringUtil.joinPaths(OPENCMS_PATH_PREFIX, path);
              resourceURL = OpenCms.getSystemInfo().getClass().getClassLoader().getResource(path);
          }
          return resourceURL;
      }
  
      /**
       * Returns if the given URI points to a static resource.<p>
       *
       * @param path the path to test
       *
       * @return <code>true</code> in case the given URI points to a static resource
       */
      public static boolean isStaticResourceUri(String path) {
  
          return (path != null) && path.matches(getStaticResourceRegex());
  
      }
  
      /**
       * Returns if the given URI points to a static resource.<p>
       *
       * @param uri the URI to test
       *
       * @return <code>true</code> in case the given URI points to a static resource
       */
      public static boolean isStaticResourceUri(URI uri) {
  
          return (uri != null) && isStaticResourceUri(uri.getPath());
  
      }
  
      /**
       * Removes the static resource path prefix.<p>
       *
       * @param path the path
       *
       * @return the modified path
       */
      public static String removeStaticResourcePrefix(String path) {
  
          return path.replaceFirst(getRemovePrefixRegex(), "");
      }
  
      /**
       * Returns the regular expression to remove the static resource path prefix.<p>
       *
       * @return the regular expression to remove the static resource path prefix
       */
      private static String getRemovePrefixRegex() {
  
          if (m_removePrefixRegex == null) {
              m_removePrefixRegex = "^("
                  + OpenCms.getStaticExportManager().getVfsPrefix()
                  + ")?"
                  + STATIC_RESOURCE_PREFIX
                  + "(/v-?\\d+v/)?";
          }
          return m_removePrefixRegex;
      }
  
      /**
       * Returns the regular expression to identify static resource paths.<p>
       *
       * @return the regular expression to identify static resource paths
       */
      private static String getStaticResourceRegex() {
  
          if (m_staticResourceRegex == null) {
              m_staticResourceRegex = getRemovePrefixRegex() + ".*";
          }
          return m_staticResourceRegex;
      }
  
      /**
       * @see org.opencms.main.I_CmsRequestHandler#getHandlerNames()
       */
      public String[] getHandlerNames() {
  
          return HANDLER_NAMES;
      }
  
      /**
       * @see org.opencms.main.I_CmsRequestHandler#handle(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, java.lang.String)
       */
      public void handle(HttpServletRequest request, HttpServletResponse response, String name) throws IOException {
  
          String path = OpenCmsCore.getInstance().getPathInfo(request);
          URL resourceURL = getStaticResourceURL(path);
          if (resourceURL != null) {
              setResponseHeaders(request, response, path, resourceURL);
              writeStaticResourceResponse(request, response, resourceURL);
          } else {
              response.setStatus(HttpServletResponse.SC_NOT_FOUND);
          }
      }
  
      /**
       * Returns whether this servlet should attempt to serve a precompressed
       * version of the given static resource. If this method returns true, the
       * suffix {@code .gz} is appended to the URL and the corresponding resource
       * is served if it exists. It is assumed that the compression method used is
       * gzip. If this method returns false or a compressed version is not found,
       * the original URL is used.<p>
       *
       * The base implementation of this method returns true if and only if the
       * request indicates that the client accepts gzip compressed responses and
       * the filename extension of the requested resource is .js, .css, or .html.<p>
       *
       * @param request the request for the resource
       * @param url the URL of the requested resource
       *
       * @return true if the servlet should attempt to serve a precompressed version of the resource, false otherwise
       */
      protected boolean allowServePrecompressedResource(HttpServletRequest request, String url) {
  
          String accept = request.getHeader("Accept-Encoding");
          return (accept != null)
              && accept.contains("gzip")
              && (url.endsWith(".js") || url.endsWith(".css") || url.endsWith(".html"));
      }
  
      /**
       * Calculates the cache lifetime for the given filename in seconds. By
       * default filenames containing ".nocache." return 0, filenames containing
       * ".cache." return one year, all other return the value defined in the
       * web.xml using resourceCacheTime (defaults to 1 hour).<p>
       *
       * @param filename the file name
       *
       * @return cache lifetime for the given filename in seconds
       */
      protected int getCacheTime(String filename) {
  
          /*
           * GWT conventions:
           *
           * - files containing .nocache. will not be cached.
           *
           * - files containing .cache. will be cached for one year.
           *
           * https://developers.google.com/web-toolkit/doc/latest/
           * DevGuideCompilingAndDebugging#perfect_caching
           */
          if (filename.contains(".nocache.")) {
              return 0;
          }
          if (filename.contains(".cache.")) {
              return 60 * 60 * 24 * 365;
          }
          /*
           * For all other files, the browser is allowed to cache for 1 hour
           * without checking if the file has changed. This forces browsers to
           * fetch a new version when the Vaadin version is updated. This will
           * cause more requests to the servlet than without this but for high
           * volume sites the static files should never be served through the
           * servlet.
           */
          return DEFAULT_CACHE_TIME;
      }
  
      /**
       * Sets the response headers.<p>
       *
       * @param request the request
       * @param response the response
       * @param filename the file name
       * @param resourceURL the resource URL
       */
      protected void setResponseHeaders(
          HttpServletRequest request,
          HttpServletResponse response,
          String filename,
          URL resourceURL) {
  
          String cacheControl = "public, max-age=0, must-revalidate";
          int resourceCacheTime = getCacheTime(filename);
          if (resourceCacheTime > 0) {
              cacheControl = "max-age=" + String.valueOf(resourceCacheTime);
          }
          response.setHeader("Cache-Control", cacheControl);
          response.setDateHeader("Expires", System.currentTimeMillis() + (resourceCacheTime * 1000));
  
          // Find the modification timestamp
          long lastModifiedTime = 0;
          URLConnection connection = null;
          try {
              connection = resourceURL.openConnection();
              lastModifiedTime = connection.getLastModified();
              // Remove milliseconds to avoid comparison problems (milliseconds
              // are not returned by the browser in the "If-Modified-Since"
              // header).
              lastModifiedTime = lastModifiedTime - (lastModifiedTime % 1000);
              response.setDateHeader("Last-Modified", lastModifiedTime);
  
              if (browserHasNewestVersion(request, lastModifiedTime)) {
                  response.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                  return;
              }
          } catch (Exception e) {
              // Failed to find out last modified timestamp. Continue without it.
              LOG.debug("Failed to find out last modified timestamp. Continuing without it.", e);
          } finally {
              try {
                  if (connection != null) {
                      // Explicitly close the input stream to prevent it
                      // from remaining hanging
                      // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4257700
                      InputStream is = connection.getInputStream();
                      if (is != null) {
                          is.close();
                      }
                  }
              } catch (Exception e) {
                  LOG.info("Error closing URLConnection input stream", e);
              }
          }
  
          // Set type mime type if we can determine it based on the filename
          String mimetype = OpenCms.getResourceManager().getMimeType(filename, "UTF-8");
          if (mimetype != null) {
              response.setContentType(mimetype);
          }
      }
  
      /**
       * Writes the contents of the given resourceUrl in the response. Can be
       * overridden to add/modify response headers and similar.<p>
       *
       * @param request the request for the resource
       * @param response the response
       * @param resourceUrl the url to send
       *
       * @throws IOException in case writing the response fails
       */
      protected void writeStaticResourceResponse(
          HttpServletRequest request,
          HttpServletResponse response,
          URL resourceUrl)
      throws IOException {
  
          URLConnection connection = null;
          InputStream is = null;
          String urlStr = resourceUrl.toExternalForm();
          try {
              if (allowServePrecompressedResource(request, urlStr)) {
                  // try to serve a precompressed version if available
                  try {
                      connection = new URL(urlStr + ".gz").openConnection();
                      is = connection.getInputStream();
                      // set gzip headers
                      response.setHeader("Content-Encoding", "gzip");
                  } catch (Exception e) {
                      LOG.debug("Unexpected exception looking for gzipped version of resource " + urlStr, e);
                  }
              }
              if (is == null) {
                  // precompressed resource not available, get non compressed
                  connection = resourceUrl.openConnection();
                  try {
                      is = connection.getInputStream();
                  } catch (FileNotFoundException e) {
                      LOG.debug(e.getMessage(), e);
                      response.setStatus(HttpServletResponse.SC_NOT_FOUND);
                      return;
                  }
              }
  
              try {
                  @SuppressWarnings("null")
                  int length = connection.getContentLength();
                  if (length >= 0) {
                      response.setContentLength(length);
                  }
              } catch (Throwable e) {
                  LOG.debug(e.getMessage(), e);
                  // This can be ignored, content length header is not required.
                  // Need to close the input stream because of
                  // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4257700 to
                  // prevent it from hanging, but that is done below.
              }
  
              streamContent(response, is);
          } finally {
              if (is != null) {
                  is.close();
              }
          }
      }
  
      /**
       * Checks if the browser has an up to date cached version of requested
       * resource. Currently the check is performed using the "If-Modified-Since"
       * header. Could be expanded if needed.<p>
       *
       * @param request the HttpServletRequest from the browser
       * @param resourceLastModifiedTimestamp the timestamp when the resource was last modified. 0 if the last modification time is unknown
       *
       * @return true if the If-Modified-Since header tells the cached version in the browser is up to date, false otherwise
       */
      private boolean browserHasNewestVersion(HttpServletRequest request, long resourceLastModifiedTimestamp) {
  
          if (resourceLastModifiedTimestamp < 1) {
              // We do not know when it was modified so the browser cannot have an
              // up-to-date version
              return false;
          }
          /*
           * The browser can request the resource conditionally using an
           * If-Modified-Since header. Check this against the last modification
           * time.
           */
          try {
              // If-Modified-Since represents the timestamp of the version cached
              // in the browser
              long headerIfModifiedSince = request.getDateHeader("If-Modified-Since");
  
              if (headerIfModifiedSince >= resourceLastModifiedTimestamp) {
                  // Browser has this an up-to-date version of the resource
                  return true;
              }
          } catch (Exception e) {
              // Failed to parse header. Fail silently - the browser does not have
              // an up-to-date version in its cache.
          }
          return false;
      }
  
      /**
       * Streams the input stream to the response.<p>
       *
       * @param response the response
       * @param is the input stream
       *
       * @throws IOException in case writing to the response fails
       */
      private void streamContent(HttpServletResponse response, InputStream is) throws IOException {
  
          OutputStream os = response.getOutputStream();
          try {
              byte buffer[] = new byte[DEFAULT_BUFFER_SIZE];
              int bytes;
              while ((bytes = is.read(buffer)) >= 0) {
                  os.write(buffer, 0, bytes);
              }
          } finally {
              os.close();
          }
      }
  }
  