/*
* This library is part of OpenCms -
* the Open Source Content Management System
*
* Copyright (c) Alkacon Software GmbH (http://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 GmbH, please see the
* company website: http://www.alkacon.com
*
* For further information about OpenCms, please see the
* project website: http://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.staticexport;
import org.opencms.file.CmsObject;
import org.opencms.file.CmsProject;
import org.opencms.file.CmsResource;
import org.opencms.file.CmsResourceFilter;
import org.opencms.main.CmsException;
import org.opencms.main.CmsLog;
import org.opencms.main.CmsPermalinkResourceHandler;
import org.opencms.main.OpenCms;
import org.opencms.relations.CmsExternalLinksValidationResult;
import org.opencms.security.CmsRole;
import org.opencms.security.CmsRoleViolationException;
import org.opencms.site.CmsSite;
import org.opencms.util.CmsFileUtil;
import org.opencms.util.CmsStringUtil;
import java.net.MalformedURLException;
import java.net.URL;
import org.apache.commons.logging.Log;
/**
* Does the link replacement for the ≶link> tags.<p>
*
* Since this functionality is closely related to the static export,
* this class resides in the static export package.<p>
*
* @since 6.0.0
*/
public class CmsLinkManager {
/** The log object for this class. */
private static final Log LOG = CmsLog.getLog(CmsLinkManager.class);
/** Base URL to calculate absolute links. */
private static URL m_baseUrl;
/** The configured link substitution handler. */
private I_CmsLinkSubstitutionHandler m_linkSubstitutionHandler;
/** Stores the results of a external link validation. */
private CmsExternalLinksValidationResult m_pointerLinkValidationResult;
/**
* Public constructor.<p>
*
* @param linkSubstitutionHandler the link substitution handler to use
*/
public CmsLinkManager(I_CmsLinkSubstitutionHandler linkSubstitutionHandler) {
m_linkSubstitutionHandler = linkSubstitutionHandler;
if (m_linkSubstitutionHandler == null) {
// just make very sure that this is not null
m_linkSubstitutionHandler = new CmsDefaultLinkSubstitutionHandler();
}
}
/**
* Static initializer for the base URL.<p>
*/
static {
m_baseUrl = null;
try {
m_baseUrl = new URL("http://127.0.0.1");
} catch (MalformedURLException e) {
// this won't happen
}
}
/**
* Calculates the absolute URI for the "relativeUri" with the given absolute "baseUri" as start. <p>
*
* If "relativeUri" is already absolute, it is returned unchanged.
* This method also returns "relativeUri" unchanged if it is not well-formed.<p>
*
* @param relativeUri the relative URI to calculate an absolute URI for
* @param baseUri the base URI, this must be an absolute URI
*
* @return an absolute URI calculated from "relativeUri" and "baseUri"
*/
public static String getAbsoluteUri(String relativeUri, String baseUri) {
if (isAbsoluteUri(relativeUri)) {
// URI is null or already absolute
return relativeUri;
}
try {
URL url = new URL(new URL(m_baseUrl, baseUri), relativeUri);
StringBuffer result = new StringBuffer(100);
result.append(url.getPath());
if (url.getQuery() != null) {
result.append('?');
result.append(url.getQuery());
}
if (url.getRef() != null) {
result.append('#');
result.append(url.getRef());
}
return result.toString();
} catch (MalformedURLException e) {
return relativeUri;
}
}
/**
* Calculates a relative URI from "fromUri" to "toUri",
* both URI must be absolute.<p>
*
* @param fromUri the URI to start
* @param toUri the URI to calculate a relative path to
* @return a relative URI from "fromUri" to "toUri"
*/
public static String getRelativeUri(String fromUri, String toUri) {
StringBuffer result = new StringBuffer();
int pos = 0;
while (true) {
int i = fromUri.indexOf('/', pos);
int j = toUri.indexOf('/', pos);
if ((i == -1) || (i != j) || !fromUri.regionMatches(pos, toUri, pos, i - pos)) {
break;
}
pos = i + 1;
}
// count hops up from here to the common ancestor
for (int i = fromUri.indexOf('/', pos); i > 0; i = fromUri.indexOf('/', i + 1)) {
result.append("../");
}
// append path down from common ancestor to there
result.append(toUri.substring(pos));
if (result.length() == 0) {
// special case: relative link to the parent folder from a file in that folder
result.append("./");
}
return result.toString();
}
/**
* Returns the resource root path for the given target URI in the OpenCms VFS, or <code>null</code> in
* case the target URI points to an external site.<p>
*
* @param cms the current users OpenCms context
* @param basePath path to use as base site for the target URI (can be <code>null</code>)
* @param targetUri the target URI
*
* @return the resource root path for the given target URI in the OpenCms VFS, or <code>null</code> in
* case the target URI points to an external site
*
* @deprecated use {@link #getRootPath(CmsObject, String, String)} instead, obtain the link manager
* with {@link OpenCms#getLinkManager()}
*/
@Deprecated
public static String getSitePath(CmsObject cms, String basePath, String targetUri) {
return OpenCms.getLinkManager().getRootPath(cms, targetUri, basePath);
}
/**
* Tests if the given URI starts with a scheme component.<p>
*
* The scheme component is something like <code>http:</code> or <code>ftp:</code>.<p>
*
* @param uri the URI to test
*
* @return <code>true</code> if the given URI starts with a scheme component
*/
public static boolean hasScheme(String uri) {
int pos = uri.indexOf(':');
// don't want to be misguided by a potential ':' in the query section of the URI (is this possible / allowed?)
// so consider only a ':' in the first 10 chars as a scheme
return (pos > -1) && (pos < 10);
}
/**
* Returns <code>true</code> in case the given URI is absolute.<p>
*
* An URI is considered absolute if one of the following is true:<ul>
* <li>The URI starts with a <code>'/'</code> char.
* <li>The URI contains a <code>':'</code> in the first 10 chars.
* <li>The URI is <code>null</code>
* </ul>
*
* @param uri the URI to test
*
* @return <code>true</code> in case the given URI is absolute
*/
public static boolean isAbsoluteUri(String uri) {
return (uri == null) || ((uri.length() >= 1) && ((uri.charAt(0) == '/') || hasScheme(uri)));
}
/**
* Returns the online link for the given resource, with full server prefix.<p>
*
* Like <code>http://site.enterprise.com:8080/index.html</code>.<p>
*
* In case the resource name is a full root path, the site from the root path will be used.
* Otherwise the resource is assumed to be in the current site set be the OpenCms user context.<p>
*
* Please note that this method will always return the link as it will appear in the "Online"
* project, that is after the resource has been published. In case you need a method that
* just returns the link with the full server prefix, use {@link #getServerLink(CmsObject, String)}.<p>
*
* @param cms the current OpenCms user context
* @param resourceName the resource to generate the online link for
*
* @return the online link for the given resource, with full server prefix
*
* @see #getServerLink(CmsObject, String)
*/
public String getOnlineLink(CmsObject cms, String resourceName) {
String result = "";
try {
CmsProject currentProject = cms.getRequestContext().getCurrentProject();
try {
cms.getRequestContext().setCurrentProject(cms.readProject(CmsProject.ONLINE_PROJECT_ID));
result = substituteLinkForUnknownTarget(cms, resourceName);
result = appendServerPrefix(cms, result, resourceName);
} finally {
cms.getRequestContext().setCurrentProject(currentProject);
}
} catch (CmsException e) {
// should never happen
result = e.getLocalizedMessage();
if (LOG.isErrorEnabled()) {
LOG.error(e.getLocalizedMessage(), e);
}
}
return result;
}
/**
* Returns the perma link for the given resource.<p>
*
* Like
* <code>http://site.enterprise.com:8080/permalink/4b65369f-1266-11db-8360-bf0f6fbae1f8.html</code>.<p>
*
* @param cms the cms context
* @param resourceName the resource to generate the perma link for
*
* @return the perma link
*/
public String getPermalink(CmsObject cms, String resourceName) {
String permalink = "";
try {
permalink = substituteLink(cms, CmsPermalinkResourceHandler.PERMALINK_HANDLER);
String id = cms.readResource(resourceName, CmsResourceFilter.ALL).getStructureId().toString();
permalink += id;
String ext = CmsFileUtil.getExtension(resourceName);
if (CmsStringUtil.isNotEmptyOrWhitespaceOnly(ext)) {
permalink += ext;
}
String serverPrefix = OpenCms.getSiteManager().getCurrentSite(cms).getServerPrefix(cms, resourceName);
if (!permalink.startsWith(serverPrefix)) {
permalink = serverPrefix + permalink;
}
} catch (CmsException e) {
// if something wrong
permalink = e.getLocalizedMessage();
if (LOG.isErrorEnabled()) {
LOG.error(e.getLocalizedMessage(), e);
}
}
return permalink;
}
/**
* Returns the result of the last extern link validation.<p>
*
* @return the result of the last extern link validation
*/
public CmsExternalLinksValidationResult getPointerLinkValidationResult() {
return m_pointerLinkValidationResult;
}
/**
* Returns the resource root path in the OpenCms VFS for the given target URI link, or <code>null</code> in
* case the link points to an external site.<p>
*
* This methods does not support relative target URI links, so the given URI must be an absolute link.<p>
*
* See {@link #getRootPath(CmsObject, String)} for a full explanation of this method.<p>
*
* @param cms the current users OpenCms context
* @param targetUri the target URI link
*
* @return the resource root path in the OpenCms VFS for the given target URI link, or <code>null</code> in
* case the link points to an external site
*
* @see #getRootPath(CmsObject, String, String)
*
* @since 7.0.2
*/
public String getRootPath(CmsObject cms, String targetUri) {
return getRootPath(cms, targetUri, null);
}
/**
* Returns the resource root path in the OpenCms VFS for the given target URI link, or <code>null</code> in
* case the link points to an external site.<p>
*
* The default implementation applies the following transformations to the link:<ul>
* <li>In case the link starts with a VFS prefix (for example <code>/opencms/opencms</code>,
* this prefix is removed from the result
* <li>In case the link is not a root path, the current site root is appended to the result.<p>
* <li>In case the link is relative, it will be made absolute using the given absolute <code>basePath</code>
* as starting point.<p>
* <li>In case the link contains a server schema (for example <code>http://www.mysite.de/</code>),
* which points to a configured site in OpenCms, the server schema is replaced with
* the root path of the site.<p>
* <li>In case the link points to an external site, or in case it is not a valid URI,
* then <code>null</code> is returned.<p>
* </ul>
*
* Please note the above text describes the default behavior as implemented by
* {@link CmsDefaultLinkSubstitutionHandler}, which can be fully customized using
* the {@link I_CmsLinkSubstitutionHandler} interface.<p>
*
* @param cms the current users OpenCms context
* @param targetUri the target URI link
* @param basePath path to use as base in case the target URI is relative (can be <code>null</code>)
*
* @return the resource root path in the OpenCms VFS for the given target URI link, or <code>null</code> in
* case the link points to an external site
*
* @see I_CmsLinkSubstitutionHandler for the interface that can be used to fully customize the link substitution
* @see CmsDefaultLinkSubstitutionHandler for the default link substitution handler
*
* @since 7.0.2
*/
public String getRootPath(CmsObject cms, String targetUri, String basePath) {
return m_linkSubstitutionHandler.getRootPath(cms, targetUri, basePath);
}
/**
* Returns the link for the given resource in the current project, with full server prefix.<p>
*
* Like <code>http://site.enterprise.com:8080/index.html</code>.<p>
*
* In case the resource name is a full root path, the site from the root path will be used.
* Otherwise the resource is assumed to be in the current site set be the OpenCms user context.<p>
*
* @param cms the current OpenCms user context
* @param resourceName the resource to generate the online link for
*
* @return the link for the given resource in the current project, with full server prefix
*
* @see #getOnlineLink(CmsObject, String)
*/
public String getServerLink(CmsObject cms, String resourceName) {
String result = substituteLinkForUnknownTarget(cms, resourceName);
return appendServerPrefix(cms, result, resourceName);
}
/**
* Sets the internal link substitution handler.<p>
*
* @param cms an OpenCms user context that must have the permissions for role {@link CmsRole#ROOT_ADMIN}.<p>
* @param linkSubstitutionHandler the handler to set
*
* @throws CmsRoleViolationException in case the provided OpenCms user context does not have the required permissions
*/
public void setLinkSubstitutionHandler(CmsObject cms, I_CmsLinkSubstitutionHandler linkSubstitutionHandler)
throws CmsRoleViolationException {
OpenCms.getRoleManager().checkRole(cms, CmsRole.ROOT_ADMIN);
m_linkSubstitutionHandler = linkSubstitutionHandler;
}
/**
* Sets the result of an external link validation.<p>
*
* @param externLinkValidationResult the result an external link validation
*/
public void setPointerLinkValidationResult(CmsExternalLinksValidationResult externLinkValidationResult) {
m_pointerLinkValidationResult = externLinkValidationResult;
}
/**
* Returns a link <i>from</i> the URI stored in the provided OpenCms user context
* <i>to</i> the given VFS resource, for use on web pages.<p>
*
* The result will contain the configured context path and
* servlet name, and in the case of the "online" project it will also be rewritten according to
* to the configured static export settings.<p>
*
* Should the current site of the given OpenCms user context <code>cms</code> be different from the
* site root of the given resource, the result will contain the full server URL to the target resource.<p>
*
* Please note the above text describes the default behavior as implemented by
* {@link CmsDefaultLinkSubstitutionHandler}, which can be fully customized using the
* {@link I_CmsLinkSubstitutionHandler} interface.<p>
*
* @param cms the current OpenCms user context
* @param resource the VFS resource the link should point to
*
* @return a link <i>from</i> the URI stored in the provided OpenCms user context
* <i>to</i> the given VFS resource, for use on web pages
*/
public String substituteLink(CmsObject cms, CmsResource resource) {
return substituteLinkForRootPath(cms, resource.getRootPath());
}
/**
* Returns a link <i>from</i> the URI stored in the provided OpenCms user context
* <i>to</i> the VFS resource indicated by the given <code>link</code> in the current site,
* for use on web pages.<p>
*
* The provided <code>link</code> is assumed to be the contained in the site currently
* set in the provided OpenCms user context <code>cms</code>.<p>
*
* The result will be an absolute link that contains the configured context path and
* servlet name, and in the case of the "online" project it will also be rewritten according to
* to the configured static export settings.<p>
*
* In case <code>link</code> is a relative URI, the current URI contained in the provided
* OpenCms user context <code>cms</code> is used to make the relative <code>link</code> absolute.<p>
*
* Please note the above text describes the default behavior as implemented by
* {@link CmsDefaultLinkSubstitutionHandler}, which can be fully customized using the
* {@link I_CmsLinkSubstitutionHandler} interface.<p>
*
* @param cms the current OpenCms user context
* @param link the link to process which is assumed to point to a VFS resource, with optional parameters
* @return a link <i>from</i> the URI stored in the provided OpenCms user context
* <i>to</i> the VFS resource indicated by the given <code>link</code> in the current site
*/
public String substituteLink(CmsObject cms, String link) {
return substituteLink(cms, link, null, false);
}
/**
* Returns a link <i>from</i> the URI stored in the provided OpenCms user context
* <i>to</i> the VFS resource indicated by the given <code>link</code> and <code>siteRoot</code>,
* for use on web pages.<p>
*
* The result will be an absolute link that contains the configured context path and
* servlet name, and in the case of the "online" project it will also be rewritten according to
* to the configured static export settings.<p>
*
* In case <code>link</code> is a relative URI, the current URI contained in the provided
* OpenCms user context <code>cms</code> is used to make the relative <code>link</code> absolute.<p>
*
* The provided <code>siteRoot</code> is assumed to be the "home" of the link.
* In case the current site of the given OpenCms user context <code>cms</code> is different from the
* provided <code>siteRoot</code>, the full server prefix is appended to the result link.<p>
*
* Please note the above text describes the default behavior as implemented by
* {@link CmsDefaultLinkSubstitutionHandler}, which can be fully customized using the
* {@link I_CmsLinkSubstitutionHandler} interface.<p>
*
* @param cms the current OpenCms user context
* @param link the link to process which is assumed to point to a VFS resource, with optional parameters
* @param siteRoot the site root of the <code>link</code>
*
* @return the substituted link
*/
public String substituteLink(CmsObject cms, String link, String siteRoot) {
return substituteLink(cms, link, siteRoot, false);
}
/**
* Returns a link <i>from</i> the URI stored in the provided OpenCms user context
* <i>to</i> the VFS resource indicated by the given <code>link</code> and <code>siteRoot</code>,
* for use on web pages, using the configured link substitution handler.<p>
*
* The result will be an absolute link that contains the configured context path and
* servlet name, and in the case of the "online" project it will also be rewritten according to
* to the configured static export settings.<p>
*
* In case <code>link</code> is a relative URI, the current URI contained in the provided
* OpenCms user context <code>cms</code> is used to make the relative <code>link</code> absolute.<p>
*
* The provided <code>siteRoot</code> is assumed to be the "home" of the link.
* In case the current site of the given OpenCms user context <code>cms</code> is different from the
* provided <code>siteRoot</code>, the full server prefix is appended to the result link.<p>
*
* A server prefix is also added if
* <ul>
* <li>the link is contained in a normal document and the link references a secure document</li>
* <li>the link is contained in a secure document and the link references a normal document</li>
* </ul>
*
* Please note the above text describes the default behavior as implemented by
* {@link CmsDefaultLinkSubstitutionHandler}, which can be fully customized using the
* {@link I_CmsLinkSubstitutionHandler} interface.<p>
*
* @param cms the current OpenCms user context
* @param link the link to process which is assumed to point to a VFS resource, with optional parameters
* @param siteRoot the site root of the <code>link</code>
* @param forceSecure if <code>true</code> generates always an absolute URL (with protocol and server name) for secure links
*
* @return a link <i>from</i> the URI stored in the provided OpenCms user context
* <i>to</i> the VFS resource indicated by the given <code>link</code> and <code>siteRoot</code>
*
* @see I_CmsLinkSubstitutionHandler for the interface that can be used to fully customize the link substitution
* @see CmsDefaultLinkSubstitutionHandler for the default link substitution handler
*/
public String substituteLink(CmsObject cms, String link, String siteRoot, boolean forceSecure) {
return m_linkSubstitutionHandler.getLink(cms, link, siteRoot, forceSecure);
}
/**
* Returns a link <i>from</i> the URI stored in the provided OpenCms user context
* <i>to</i> the VFS resource indicated by the given root path, for use on web pages.<p>
*
* The result will contain the configured context path and
* servlet name, and in the case of the "online" project it will also be rewritten according to
* to the configured static export settings.<p>
*
* Should the current site of the given OpenCms user context <code>cms</code> be different from the
* site root of the given resource root path, the result will contain the full server URL to the target resource.<p>
*
* @param cms the current OpenCms user context
* @param rootPath the VFS resource root path the link should point to
*
* @return a link <i>from</i> the URI stored in the provided OpenCms user context
* <i>to</i> the VFS resource indicated by the given root path
*/
public String substituteLinkForRootPath(CmsObject cms, String rootPath) {
String siteRoot = OpenCms.getSiteManager().getSiteRoot(rootPath);
if (siteRoot == null) {
// use current site root in case no valid site root is available
// this will also be the case if a "/system" link is used
siteRoot = cms.getRequestContext().getSiteRoot();
}
String sitePath;
if (rootPath.startsWith(siteRoot)) {
// only cut the site root if the root part really has this prefix
sitePath = rootPath.substring(siteRoot.length());
} else {
sitePath = rootPath;
}
return substituteLink(cms, sitePath, siteRoot, false);
}
/**
* Returns a link <i>from</i> the URI stored in the provided OpenCms user context
* <i>to</i> the given <code>link</code>, for use on web pages.<p>
*
* A number of tests are performed with the <code>link</code> in order to find out how to create the link:<ul>
* <li>If <code>link</code> is empty, an empty String is returned.
* <li>If <code>link</code> starts with an URI scheme component, for example <code>http://</code>,
* and does not point to an internal OpenCms site, it is returned unchanged.
* <li>If <code>link</code> is an absolute URI that starts with a configured site root,
* the site root is cut from the link and
* the same result as {@link #substituteLink(CmsObject, String, String)} is returned.
* <li>Otherwise the same result as {@link #substituteLink(CmsObject, String)} is returned.
* </ul>
*
* @param cms the current OpenCms user context
* @param link the link to process
*
* @return a link <i>from</i> the URI stored in the provided OpenCms user context
* <i>to</i> the given <code>link</code>
*/
public String substituteLinkForUnknownTarget(CmsObject cms, String link) {
if (CmsStringUtil.isEmpty(link)) {
return "";
}
String sitePath = link;
String siteRoot = null;
if (hasScheme(link)) {
// the link has a scheme, that is starts with something like "http://"
// usually this should be a link to an external resource, but check anyway
sitePath = getRootPath(cms, link);
if (sitePath == null) {
// probably an external link, don't touch this
return link;
}
}
// check if we can find a site from the link
siteRoot = OpenCms.getSiteManager().getSiteRoot(sitePath);
if (siteRoot == null) {
// use current site root in case no valid site root is available
// this will also be the case if a "/system" link is used
siteRoot = cms.getRequestContext().getSiteRoot();
} else {
// we found a site root, cut this from the resource path
sitePath = sitePath.substring(siteRoot.length());
}
return substituteLink(cms, sitePath, siteRoot, false);
}
/**
* Returns the link for the given resource in the current project, with full server prefix.<p>
*
* The input link must already have been processed according to the link substitution rules.
* This method does just append the server prefix in case this is requires.<p>
*
* @param cms the current OpenCms user context
* @param link the resource to generate the online link for
*
* @return the link for the given resource in the current project, with full server prefix
*/
private String appendServerPrefix(CmsObject cms, String link, String resourceName) {
if (isAbsoluteUri(link) && !hasScheme(link)) {
// URI is absolute and contains no schema
// this indicates source and target link are in the same site
String serverPrefix;
if (cms.getRequestContext().getCurrentProject().isOnlineProject()) {
// on online project, get the real site name from the site manager
CmsSite currentSite = OpenCms.getSiteManager().getSite(
resourceName,
cms.getRequestContext().getSiteRoot());
serverPrefix = currentSite.getServerPrefix(cms, resourceName);
} else {
// in offline mode, source must be the workplace
// so append the workplace server so links can still be clicked
serverPrefix = OpenCms.getSiteManager().getWorkplaceServer();
}
link = serverPrefix + link;
}
return link;
}
}