| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package freemarker.ext.jsp; |
| |
| import java.beans.IntrospectionException; |
| import java.io.ByteArrayInputStream; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FilenameFilter; |
| import java.io.FilterInputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.UnsupportedEncodingException; |
| import java.lang.reflect.Method; |
| import java.lang.reflect.Modifier; |
| import java.net.JarURLConnection; |
| import java.net.MalformedURLException; |
| import java.net.URISyntaxException; |
| import java.net.URL; |
| import java.net.URLConnection; |
| import java.net.URLDecoder; |
| import java.net.URLEncoder; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.Enumeration; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.Stack; |
| import java.util.TreeSet; |
| import java.util.jar.JarEntry; |
| import java.util.jar.JarFile; |
| import java.util.regex.Pattern; |
| import java.util.zip.ZipEntry; |
| import java.util.zip.ZipException; |
| import java.util.zip.ZipInputStream; |
| |
| import javax.servlet.ServletContext; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.jsp.tagext.Tag; |
| import javax.xml.parsers.ParserConfigurationException; |
| import javax.xml.parsers.SAXParserFactory; |
| |
| import org.xml.sax.Attributes; |
| import org.xml.sax.EntityResolver; |
| import org.xml.sax.InputSource; |
| import org.xml.sax.Locator; |
| import org.xml.sax.SAXException; |
| import org.xml.sax.SAXParseException; |
| import org.xml.sax.XMLReader; |
| import org.xml.sax.helpers.DefaultHandler; |
| |
| import freemarker.core.BugException; |
| import freemarker.core.Environment; |
| import freemarker.ext.beans.BeansWrapper; |
| import freemarker.ext.servlet.FreemarkerServlet; |
| import freemarker.ext.servlet.HttpRequestHashModel; |
| import freemarker.log.Logger; |
| import freemarker.template.DefaultObjectWrapper; |
| import freemarker.template.ObjectWrapper; |
| import freemarker.template.TemplateHashModel; |
| import freemarker.template.TemplateMethodModelEx; |
| import freemarker.template.TemplateModel; |
| import freemarker.template.TemplateModelException; |
| import freemarker.template.TemplateTransformModel; |
| import freemarker.template.utility.ClassUtil; |
| import freemarker.template.utility.NullArgumentException; |
| import freemarker.template.utility.SecurityUtilities; |
| import freemarker.template.utility.StringUtil; |
| |
| /** |
| * A hash model associated with a servlet context that can load JSP tag libraries associated with that servlet context. |
| * An instance of this class is made available in the root data model of templates executed by |
| * {@link freemarker.ext.servlet.FreemarkerServlet} under key {@code JspTaglibs}. It can be added to custom servlets as |
| * well to enable JSP taglib integration in them as well. |
| */ |
| public class TaglibFactory implements TemplateHashModel { |
| |
| /** |
| * The default of {@link #getClasspathTlds()}; an empty list. |
| * |
| * @since 2.3.22 |
| */ |
| public static final List DEFAULT_CLASSPATH_TLDS = Collections.EMPTY_LIST; |
| |
| /** |
| * The default of {@link #getMetaInfTldSources()}; a list that contains |
| * {@link WebInfPerLibJarMetaInfTldSource#INSTANCE}, which gives the behavior described in the JSP 2.2 |
| * specification. |
| * |
| * @since 2.3.22 |
| */ |
| public static final List/*<? extends MetaInfTldSource>*/ DEFAULT_META_INF_TLD_SOURCES |
| = Collections.singletonList(WebInfPerLibJarMetaInfTldSource.INSTANCE); |
| |
| private static final Logger LOG = Logger.getLogger("freemarker.jsp"); |
| |
| private static final int URL_TYPE_FULL = 0; |
| private static final int URL_TYPE_ABSOLUTE = 1; |
| private static final int URL_TYPE_RELATIVE = 2; |
| |
| private static final String META_INF_REL_PATH = "META-INF/"; |
| private static final String META_INF_ABS_PATH = "/META-INF/"; |
| private static final String DEFAULT_TLD_RESOURCE_PATH = META_INF_ABS_PATH + "taglib.tld"; |
| private static final String JAR_URL_ENTRY_PATH_START = "!/"; |
| |
| private static final String PLATFORM_FILE_ENCODING = SecurityUtilities.getSystemProperty("file.encoding", "utf-8"); |
| |
| private final ServletContext servletContext; |
| |
| private ObjectWrapper objectWrapper; |
| private List/*<MetaInfTldSource>*/ metaInfTldSources = DEFAULT_META_INF_TLD_SOURCES; |
| private List/*<String>*/ classpathTlds = DEFAULT_CLASSPATH_TLDS; |
| |
| boolean test_emulateNoUrlToFileConversions = false; |
| boolean test_emulateNoJarURLConnections = false; |
| boolean test_emulateJarEntryUrlOpenStreamFails = false; |
| |
| private final Object lock = new Object(); |
| private final Map taglibs = new HashMap(); |
| private final Map tldLocations = new HashMap(); |
| private List/*<String>*/ failedTldLocations = new ArrayList(); |
| private int nextTldLocationLookupPhase = 0; |
| |
| /** |
| /** |
| * Creates a new JSP taglib factory that will be used to load JSP tag libraries and functions for the web |
| * application represented by the passed in {@link ServletContext}. |
| * You should at least call {@link #setObjectWrapper(ObjectWrapper)} before start using this object. |
| * |
| * <p>This object is only thread-safe after you have stopped calling its setter methods (and it was properly |
| * published to the other threads; see JSR 133 (Java Memory Model)). |
| * |
| * @param ctx |
| * The servlet context whose JSP tag libraries this factory will load. |
| */ |
| public TaglibFactory(ServletContext ctx) { |
| this.servletContext = ctx; |
| } |
| |
| /** |
| * Retrieves a JSP tag library identified by an URI. The matching of the URI to a JSP taglib is done as described in |
| * the JSP 1.2 FCS specification. |
| * |
| * @param taglibUri |
| * The URI used in templates to refer to the taglib (like {@code <%@ taglib uri="..." ... %>} in |
| * JSP). It can be any of the three forms allowed by the JSP specification: absolute URI (like |
| * {@code http://example.com/foo}), root relative URI (like {@code /bar/foo.tld}) and non-root relative |
| * URI (like {@code bar/foo.tld}). Note that if a non-root relative URI is used it's resolved relative to |
| * the URL of the current request. In this case, the current request is obtained by looking up a |
| * {@link HttpRequestHashModel} object named <tt>Request</tt> in the root data model. |
| * {@link FreemarkerServlet} provides this object under the expected name, and custom servlets that want |
| * to integrate JSP taglib support should do the same. |
| * |
| * @return a {@link TemplateHashModel} representing the JSP taglib. Each element of this hash represents a single |
| * custom tag or EL function from the library, implemented as a {@link TemplateTransformModel} or |
| * {@link TemplateMethodModelEx}, respectively. |
| */ |
| public TemplateModel get(final String taglibUri) throws TemplateModelException { |
| synchronized (lock) { |
| { |
| final Taglib taglib = (Taglib) taglibs.get(taglibUri); |
| if (taglib != null) { |
| return taglib; |
| } |
| } |
| |
| boolean failedTldListAlreadyIncluded = false; |
| final TldLocation tldLocation; |
| final String normalizedTaglibUri; |
| try { |
| if (LOG.isDebugEnabled()) { |
| LOG.debug("Locating TLD for taglib URI " + StringUtil.jQuoteNoXSS(taglibUri) + "."); |
| } |
| |
| TldLocation explicitlyMappedTldLocation = getExplicitlyMappedTldLocation(taglibUri); |
| if (explicitlyMappedTldLocation != null) { |
| tldLocation = explicitlyMappedTldLocation; |
| normalizedTaglibUri = taglibUri; |
| } else { |
| // Taglib URI must be directly the path (no mapping). |
| |
| final int urlType; |
| try { |
| urlType = getUriType(taglibUri); |
| } catch (MalformedURLException e) { |
| throw new TaglibGettingException("Malformed taglib URI: " + StringUtil.jQuote(taglibUri), e); |
| } |
| if (urlType == URL_TYPE_RELATIVE) { |
| normalizedTaglibUri = resolveRelativeUri(taglibUri); |
| } else if (urlType == URL_TYPE_ABSOLUTE) { |
| normalizedTaglibUri = taglibUri; |
| } else if (urlType == URL_TYPE_FULL) { |
| // Per spec., full URI-s can only be resolved through explicit mapping |
| String failedTLDsList = getFailedTLDsList(); |
| failedTldListAlreadyIncluded = true; |
| throw new TaglibGettingException("No TLD was found for the " |
| + StringUtil.jQuoteNoXSS(taglibUri) + " JSP taglib URI. (TLD-s are searched according " |
| + "the JSP 2.2 specification. In development- and embedded-servlet-container " |
| + "setups you may also need the " |
| + "\"" + FreemarkerServlet.INIT_PARAM_META_INF_TLD_LOCATIONS + "\" and " |
| + "\"" + FreemarkerServlet.INIT_PARAM_CLASSPATH_TLDS + "\" " |
| + FreemarkerServlet.class.getName() + " init-params or the similar system " |
| + "properites." |
| + (failedTLDsList == null |
| ? "" |
| : " Also note these TLD-s were skipped earlier due to errors; " |
| + "see error in the log: " + failedTLDsList |
| ) + ")"); |
| } else { |
| throw new BugException(); |
| } |
| |
| if (!normalizedTaglibUri.equals(taglibUri)) { |
| final Taglib taglib = (Taglib) taglibs.get(normalizedTaglibUri); |
| if (taglib != null) { |
| return taglib; |
| } |
| } |
| |
| tldLocation = isJarPath(normalizedTaglibUri) |
| ? (TldLocation) new ServletContextJarEntryTldLocation( |
| normalizedTaglibUri, DEFAULT_TLD_RESOURCE_PATH) |
| : (TldLocation) new ServletContextTldLocation(normalizedTaglibUri); |
| } |
| } catch (Exception e) { |
| String failedTLDsList = failedTldListAlreadyIncluded ? null : getFailedTLDsList(); |
| throw new TemplateModelException( |
| "Error while looking for TLD file for " + StringUtil.jQuoteNoXSS(taglibUri) |
| + "; see cause exception." |
| + (failedTLDsList == null |
| ? "" |
| : " (Note: These TLD-s were skipped earlier due to errors; " |
| + "see errors in the log: " + failedTLDsList + ")"), |
| e); |
| } |
| |
| try { |
| return loadTaglib(tldLocation, normalizedTaglibUri); |
| } catch (Exception e) { |
| throw new TemplateModelException("Error while loading tag library for URI " |
| + StringUtil.jQuoteNoXSS(normalizedTaglibUri) + " from TLD location " |
| + StringUtil.jQuoteNoXSS(tldLocation) + "; see cause exception.", |
| e); |
| } |
| } |
| } |
| |
| /** |
| * Returns the joined list of failed TLD-s, or {@code null} if there was none. |
| */ |
| private String getFailedTLDsList() { |
| synchronized (failedTldLocations) { |
| if (failedTldLocations.isEmpty()) { |
| return null; |
| } |
| StringBuilder sb = new StringBuilder(); |
| for (int i = 0; i < failedTldLocations.size(); i++) { |
| if (i != 0) { |
| sb.append(", "); |
| } |
| sb.append(StringUtil.jQuote(failedTldLocations.get(i))); |
| } |
| return sb.toString(); |
| } |
| } |
| |
| /** |
| * Returns false. |
| */ |
| public boolean isEmpty() { |
| return false; |
| } |
| |
| /** |
| * See {@link #setObjectWrapper(ObjectWrapper)}. |
| * |
| * @since 2.3.22 |
| */ |
| public ObjectWrapper getObjectWrapper() { |
| return objectWrapper; |
| } |
| |
| /** |
| * Sets the {@link ObjectWrapper} used when building the JSP tag library {@link TemplateHashModel}-s from the TLD-s. |
| * Usually, it should be the same {@link ObjectWrapper} that will be used inside the templates. {@code null} value |
| * is only supported for backward compatibility. For custom EL functions to be exposed, it must be non-{@code null} |
| * and an {@code intanceof} {@link BeansWrapper} (like typically, a {@link DefaultObjectWrapper}). |
| * |
| * @since 2.3.22 |
| */ |
| public void setObjectWrapper(ObjectWrapper objectWrapper) { |
| checkNotStarted(); |
| this.objectWrapper = objectWrapper; |
| } |
| |
| /** |
| * See {@link #setMetaInfTldSources(List)}. |
| * |
| * @since 2.3.22 |
| */ |
| public List/*<Pattern>*/ getMetaInfTldSources() { |
| return metaInfTldSources; |
| } |
| |
| /** |
| * Sets the list of places where we will look for {@code META-INF/**}{@code /*.tld} files. By default this is a list |
| * that only contains {@link WebInfPerLibJarMetaInfTldSource#INSTANCE}. This corresponds to the behavior that the |
| * JSP specification describes. See the {@link MetaInfTldSource} subclasses for the possible values and their |
| * meanings. |
| * |
| * <p> |
| * This is usually set via the init-params of {@link FreemarkerServlet}. |
| * |
| * @param metaInfTldSources |
| * The list of {@link MetaInfTldSource} subclass instances. Their order matters if multiple TLD-s define |
| * a taglib with the same {@code taglib-uri}. In that case, the one found by the earlier |
| * {@link MetaInfTldSource} wins. |
| * |
| * @see #setClasspathTlds(List) |
| * |
| * @since 2.3.22 |
| */ |
| public void setMetaInfTldSources(List/*<? extends MetaInfTldSource>*/ metaInfTldSources) { |
| checkNotStarted(); |
| NullArgumentException.check("metaInfTldSources", metaInfTldSources); |
| this.metaInfTldSources = metaInfTldSources; |
| } |
| |
| /** |
| * See {@link #setClasspathTlds(List)}. |
| * |
| * @since 2.3.22 |
| */ |
| public List/*<String>*/ getClasspathTlds() { |
| return classpathTlds; |
| } |
| |
| /** |
| * Sets the class-loader resource paths of the TLD-s that aren't inside the locations covered by |
| * {@link #setMetaInfTldSources(List)}, yet you want them to be discovered. They will be loaded with the class |
| * loader provided by the servlet container. |
| * |
| * <p> |
| * This is usually set via the init-params of {@link FreemarkerServlet}. |
| * |
| * @param classpathTlds |
| * List of {@code String}-s, maybe {@code null}. Each item is a resource path, like |
| * {@code "/META-INF/my.tld"}. (Relative resource paths will be interpreted as root-relative.) |
| * |
| * @see #setMetaInfTldSources(List) |
| * |
| * @since 2.3.22 |
| */ |
| public void setClasspathTlds(List/*<String>*/ classpathTlds) { |
| checkNotStarted(); |
| NullArgumentException.check("classpathTlds", classpathTlds); |
| this.classpathTlds = classpathTlds; |
| } |
| |
| private void checkNotStarted() { |
| synchronized (lock) { |
| if (nextTldLocationLookupPhase != 0) { |
| throw new IllegalStateException(TaglibFactory.class.getName() + " object was already in use."); |
| } |
| } |
| } |
| |
| private TldLocation getExplicitlyMappedTldLocation(final String uri) throws SAXException, IOException, |
| TaglibGettingException { |
| while (true) { |
| final TldLocation tldLocation = (TldLocation) tldLocations.get(uri); |
| if (tldLocation != null) { |
| return tldLocation; |
| } |
| |
| switch (nextTldLocationLookupPhase) { |
| case 0: |
| // Not in JSP spec. |
| addTldLocationsFromClasspathTlds(); |
| break; |
| case 1: |
| // JSP 2.2 spec / JSP.7.3.3 (also JSP.3.2) |
| addTldLocationsFromWebXml(); |
| break; |
| case 2: |
| // JSP 2.2 spec / JSP.7.3.4, FM-specific TLD processing order #1 |
| addTldLocationsFromWebInfTlds(); |
| break; |
| case 3: |
| // JSP 2.2 spec / JSP.7.3.4, FM-specific TLD processing order #2 |
| addTldLocationsFromMetaInfTlds(); |
| break; |
| case 4: |
| return null; |
| default: |
| throw new BugException(); |
| } |
| nextTldLocationLookupPhase++; |
| } |
| } |
| |
| private void addTldLocationsFromWebXml() throws SAXException, IOException { |
| LOG.debug("Looking for TLD locations in servletContext:/WEB-INF/web.xml"); |
| |
| WebXmlParser webXmlParser = new WebXmlParser(); |
| InputStream in = servletContext.getResourceAsStream("/WEB-INF/web.xml"); |
| if (in == null) { |
| LOG.debug("No web.xml was found in servlet context"); |
| return; |
| } |
| try { |
| parseXml(in, servletContext.getResource("/WEB-INF/web.xml").toExternalForm(), webXmlParser); |
| } finally { |
| in.close(); |
| } |
| } |
| |
| private void addTldLocationsFromWebInfTlds() |
| throws IOException, SAXException { |
| LOG.debug("Looking for TLD locations in servletContext:/WEB-INF/**/*.tld"); |
| addTldLocationsFromServletContextResourceTlds("/WEB-INF"); |
| } |
| |
| private void addTldLocationsFromServletContextResourceTlds(String basePath) |
| throws IOException, SAXException { |
| Set unsortedResourcePaths = servletContext.getResourcePaths(basePath); |
| if (unsortedResourcePaths != null) { |
| List/*<String>*/ resourcePaths = new ArrayList/*<String>*/(unsortedResourcePaths); |
| Collections.sort(resourcePaths); |
| // First process the files... |
| for (Iterator it = resourcePaths.iterator(); it.hasNext(); ) { |
| String resourcePath = (String) it.next(); |
| if (resourcePath.endsWith(".tld")) { |
| addTldLocationFromTld(new ServletContextTldLocation(resourcePath)); |
| } |
| } |
| // ... only later the directories |
| for (Iterator it = resourcePaths.iterator(); it.hasNext(); ) { |
| String resourcePath = (String) it.next(); |
| if (resourcePath.endsWith("/")) { |
| addTldLocationsFromServletContextResourceTlds(resourcePath); |
| } |
| } |
| } |
| } |
| |
| private void addTldLocationsFromMetaInfTlds() throws IOException, SAXException { |
| if (metaInfTldSources == null || metaInfTldSources.isEmpty()) { |
| return; |
| } |
| |
| Set/*<URLWithExternalForm>*/ cpMetaInfDirUrlsWithEF = null; |
| |
| // Skip past the last "clear": |
| int srcIdxStart = 0; |
| for (int i = metaInfTldSources.size() - 1; i >= 0; i--) { |
| if (metaInfTldSources.get(i) instanceof ClearMetaInfTldSource) { |
| srcIdxStart = i + 1; |
| break; |
| } |
| } |
| |
| for (int srcIdx = srcIdxStart; srcIdx < metaInfTldSources.size(); srcIdx++) { |
| MetaInfTldSource miTldSource = (MetaInfTldSource) metaInfTldSources.get(srcIdx); |
| |
| if (miTldSource == WebInfPerLibJarMetaInfTldSource.INSTANCE) { |
| addTldLocationsFromWebInfPerLibJarMetaInfTlds(); |
| } else if (miTldSource instanceof ClasspathMetaInfTldSource) { |
| ClasspathMetaInfTldSource cpMiTldLocation = (ClasspathMetaInfTldSource) miTldSource; |
| if (LOG.isDebugEnabled()) { |
| LOG.debug("Looking for TLD-s in " |
| + "classpathRoots[" + cpMiTldLocation.getRootContainerPattern() + "]" |
| + META_INF_ABS_PATH + "**/*.tld"); |
| } |
| |
| if (cpMetaInfDirUrlsWithEF == null) { |
| cpMetaInfDirUrlsWithEF = collectMetaInfUrlsFromClassLoaders(); |
| } |
| |
| for (Iterator iterator = cpMetaInfDirUrlsWithEF.iterator(); iterator.hasNext(); ) { |
| URLWithExternalForm urlWithEF = (URLWithExternalForm) iterator.next(); |
| final URL url = urlWithEF.getUrl(); |
| final boolean isJarUrl = isJarUrl(url); |
| final String urlEF = urlWithEF.externalForm; |
| |
| final String rootContainerUrl; |
| if (isJarUrl) { |
| int sep = urlEF.indexOf(JAR_URL_ENTRY_PATH_START); |
| rootContainerUrl = sep != -1 ? urlEF.substring(0, sep) : urlEF; |
| } else { |
| rootContainerUrl = urlEF.endsWith(META_INF_ABS_PATH) |
| ? urlEF.substring(0, urlEF.length() - META_INF_REL_PATH.length()) |
| : urlEF; |
| } |
| |
| if (cpMiTldLocation.getRootContainerPattern().matcher(rootContainerUrl).matches()) { |
| final File urlAsFile = urlToFileOrNull(url); |
| if (urlAsFile != null) { |
| addTldLocationsFromFileDirectory(urlAsFile); |
| } else if (isJarUrl) { |
| addTldLocationsFromJarDirectoryEntryURL(url); |
| } else { |
| if (LOG.isDebugEnabled()) { |
| LOG.warn("Can't list entries under this URL; TLD-s won't be discovered here: " |
| + urlWithEF.getExternalForm()); |
| } |
| } |
| } |
| } |
| } else { |
| throw new BugException(); |
| } |
| } |
| } |
| |
| private void addTldLocationsFromWebInfPerLibJarMetaInfTlds() throws IOException, SAXException { |
| if (LOG.isDebugEnabled()) { |
| LOG.debug("Looking for TLD locations in servletContext:/WEB-INF/lib/*.{jar,zip}" + META_INF_ABS_PATH |
| + "*.tld"); |
| } |
| |
| Set libEntPaths = servletContext.getResourcePaths("/WEB-INF/lib"); |
| if (libEntPaths != null) { |
| for (Iterator iter = libEntPaths.iterator(); iter.hasNext(); ) { |
| final String libEntryPath = (String) iter.next(); |
| if (isJarPath(libEntryPath)) { |
| addTldLocationsFromServletContextJar(libEntryPath); |
| } |
| } |
| } |
| } |
| |
| private void addTldLocationsFromClasspathTlds() throws SAXException, IOException, TaglibGettingException { |
| if (classpathTlds == null || classpathTlds.size() == 0) { |
| return; |
| } |
| |
| LOG.debug("Looking for TLD locations in TLD-s specified in cfg.classpathTlds"); |
| |
| for (Iterator it = classpathTlds.iterator(); it.hasNext(); ) { |
| String tldResourcePath = (String) it.next(); |
| if (tldResourcePath.trim().length() == 0) { |
| throw new TaglibGettingException("classpathTlds can't contain empty item"); |
| } |
| |
| if (!tldResourcePath.startsWith("/")) { |
| tldResourcePath = "/" + tldResourcePath; |
| } |
| if (tldResourcePath.endsWith("/")) { |
| throw new TaglibGettingException("classpathTlds can't specify a directory: " + tldResourcePath); |
| } |
| |
| ClasspathTldLocation tldLocation = new ClasspathTldLocation(tldResourcePath); |
| InputStream in; |
| try { |
| in = tldLocation.getInputStream(); |
| } catch (IOException e) { |
| if (LOG.isWarnEnabled()) { |
| LOG.warn("Ignored classpath TLD location " + StringUtil.jQuoteNoXSS(tldResourcePath) |
| + " because of error", e); |
| } |
| in = null; |
| } |
| if (in != null) { |
| try { |
| addTldLocationFromTld(in, tldLocation); |
| } finally { |
| in.close(); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Finds and processes *.tld inside a jar in the servet context. |
| */ |
| private void addTldLocationsFromServletContextJar( |
| final String jarResourcePath) |
| throws IOException, MalformedURLException, SAXException { |
| final String metaInfEntryPath = normalizeJarEntryPath(META_INF_ABS_PATH, true); |
| |
| // Null for non-random-access backing resource: |
| final JarFile jarFile = servletContextResourceToFileOrNull(jarResourcePath); |
| if (jarFile != null) { |
| if (LOG.isDebugEnabled()) { |
| LOG.debug("Scanning for " + META_INF_ABS_PATH + "*.tld-s in JarFile: servletContext:" |
| + jarResourcePath); |
| } |
| for (Enumeration/*<JarEntry>*/ entries = jarFile.entries(); entries.hasMoreElements(); ) { |
| final JarEntry curEntry = (JarEntry) entries.nextElement(); |
| final String curEntryPath = normalizeJarEntryPath(curEntry.getName(), false); |
| if (curEntryPath.startsWith(metaInfEntryPath) && curEntryPath.endsWith(".tld")) { |
| addTldLocationFromTld(new ServletContextJarEntryTldLocation(jarResourcePath, curEntryPath)); |
| } |
| } |
| } else { // jarFile == null => fall back to streamed access |
| if (LOG.isDebugEnabled()) { |
| LOG.debug("Scanning for " + META_INF_ABS_PATH |
| + "*.tld-s in ZipInputStream (slow): servletContext:" + jarResourcePath); |
| } |
| |
| final InputStream in = servletContext.getResourceAsStream(jarResourcePath); |
| if (in == null) { |
| throw new IOException("ServletContext resource not found: " + jarResourcePath); |
| } |
| try { |
| ZipInputStream zipIn = new ZipInputStream(in); |
| try { |
| while (true) { |
| ZipEntry curEntry = zipIn.getNextEntry(); |
| if (curEntry == null) break; |
| |
| String curEntryPath = normalizeJarEntryPath(curEntry.getName(), false); |
| if (curEntryPath.startsWith(metaInfEntryPath) && curEntryPath.endsWith(".tld")) { |
| addTldLocationFromTld(zipIn, |
| new ServletContextJarEntryTldLocation(jarResourcePath, curEntryPath)); |
| } |
| } |
| } finally { |
| zipIn.close(); |
| } |
| } finally { |
| in.close(); |
| } |
| } |
| } |
| |
| /** |
| * Finds and processes *.tld inside a directory in a jar. |
| * |
| * @param jarBaseEntryUrl |
| * Something like "jar:file:/C:/foo%20bar/baaz.jar!/META-INF/". If this is not a jar(-like) URL, the |
| * behavior is undefined. |
| */ |
| private void addTldLocationsFromJarDirectoryEntryURL(final URL jarBaseEntryUrl) |
| throws IOException, MalformedURLException, SAXException { |
| // Null for non-random-access backing resource: |
| final JarFile jarFile; |
| // Not null; the path of the directory *inside* the JAR where we will search |
| // (like "/META-INF/" in "jar:file:/C:/foo%20bar/baaz.jar!/META-INF/"): |
| final String baseEntryPath; |
| // Null when URLConnection is used |
| // (like "file:/C:/foo%20bar/baaz.jar" in "jar:file:/C:/foo%20bar/baaz.jar!/META-INF/"): |
| final String rawJarContentUrlEF; |
| { |
| final URLConnection urlCon = jarBaseEntryUrl.openConnection(); |
| if (!test_emulateNoJarURLConnections && urlCon instanceof JarURLConnection) { |
| final JarURLConnection jarCon = (JarURLConnection) urlCon; |
| jarFile = jarCon.getJarFile(); |
| rawJarContentUrlEF = null; // Not used as we have a JarURLConnection |
| baseEntryPath = normalizeJarEntryPath(jarCon.getEntryName(), true); |
| if (baseEntryPath == null) { |
| throw newFailedToExtractEntryPathException(jarBaseEntryUrl); |
| } |
| } else { |
| final String jarBaseEntryUrlEF = jarBaseEntryUrl.toExternalForm(); |
| final int jarEntrySepIdx = jarBaseEntryUrlEF.indexOf(JAR_URL_ENTRY_PATH_START); |
| if (jarEntrySepIdx == -1) { |
| throw newFailedToExtractEntryPathException(jarBaseEntryUrl); |
| } |
| rawJarContentUrlEF = jarBaseEntryUrlEF.substring(jarBaseEntryUrlEF.indexOf(':') + 1, jarEntrySepIdx); |
| baseEntryPath = normalizeJarEntryPath( |
| jarBaseEntryUrlEF.substring(jarEntrySepIdx + JAR_URL_ENTRY_PATH_START.length()), true); |
| |
| File rawJarContentAsFile = urlToFileOrNull(new URL(rawJarContentUrlEF)); |
| jarFile = rawJarContentAsFile != null ? new JarFile(rawJarContentAsFile) : null; |
| } |
| } |
| if (jarFile != null) { // jarFile == null => fall back to streamed access |
| if (LOG.isDebugEnabled()) { |
| LOG.debug("Scanning for " + META_INF_ABS_PATH + "**/*.tld-s in random access mode: " |
| + jarBaseEntryUrl); |
| } |
| for (Enumeration/*<JarEntry>*/ entries = jarFile.entries(); entries.hasMoreElements(); ) { |
| final JarEntry curEntry = (JarEntry) entries.nextElement(); |
| final String curEntryPath = normalizeJarEntryPath(curEntry.getName(), false); |
| if (curEntryPath.startsWith(baseEntryPath) && curEntryPath.endsWith(".tld")) { |
| final String curEntryBaseRelativePath = curEntryPath.substring(baseEntryPath.length()); |
| final URL tldUrl = createJarEntryUrl(jarBaseEntryUrl, curEntryBaseRelativePath); |
| addTldLocationFromTld(new JarEntryUrlTldLocation(tldUrl, null)); |
| } |
| } |
| } else { |
| // Not a random-access file, so we fall back to the slower ZipInputStream approach. |
| if (LOG.isDebugEnabled()) { |
| LOG.debug("Scanning for " + META_INF_ABS_PATH + "**/*.tld-s in stream mode (slow): " |
| + rawJarContentUrlEF); |
| } |
| |
| final InputStream in = new URL(rawJarContentUrlEF).openStream(); |
| try { |
| ZipInputStream zipIn = new ZipInputStream(in); |
| try { |
| while (true) { |
| ZipEntry curEntry = zipIn.getNextEntry(); |
| if (curEntry == null) break; |
| |
| String curEntryPath = normalizeJarEntryPath(curEntry.getName(), false); |
| if (curEntryPath.startsWith(baseEntryPath) && curEntryPath.endsWith(".tld")) { |
| final String curEntryBaseRelativePath = curEntryPath.substring(baseEntryPath.length()); |
| final URL tldUrl = createJarEntryUrl(jarBaseEntryUrl, curEntryBaseRelativePath); |
| addTldLocationFromTld(zipIn, new JarEntryUrlTldLocation(tldUrl, null)); |
| } |
| } |
| } finally { |
| zipIn.close(); |
| } |
| } catch (ZipException e) { |
| // ZipException messages miss the zip URL |
| IOException ioe = new IOException("Error reading ZIP (see cause excepetion) from: " |
| + rawJarContentUrlEF); |
| try { |
| ioe.initCause(e); |
| } catch (Exception e2) { |
| throw e; |
| } |
| throw ioe; |
| } finally { |
| in.close(); |
| } |
| } |
| } |
| |
| private void addTldLocationsFromFileDirectory(final File dir) throws IOException, SAXException { |
| if (dir.isDirectory()) { |
| if (LOG.isDebugEnabled()) { |
| LOG.debug("Scanning for *.tld-s in File directory: " + StringUtil.jQuoteNoXSS(dir)); |
| } |
| File[] tldFiles = dir.listFiles(new FilenameFilter() { |
| |
| public boolean accept(File urlAsFile, String name) { |
| return isTldFileNameIgnoreCase(name); |
| } |
| |
| }); |
| if (tldFiles == null) { |
| throw new IOException("Can't list this directory for some reason: " + dir); |
| } |
| for (int i = 0; i < tldFiles.length; i++) { |
| final File file = tldFiles[i]; |
| addTldLocationFromTld(new FileTldLocation(file)); |
| } |
| } else { |
| LOG.warn("Skipped scanning for *.tld for non-existent directory: " + StringUtil.jQuoteNoXSS(dir)); |
| } |
| } |
| |
| /** |
| * Adds the TLD location mapping from the TLD itself. |
| */ |
| private void addTldLocationFromTld(TldLocation tldLocation) throws IOException, SAXException { |
| InputStream in = tldLocation.getInputStream(); |
| try { |
| addTldLocationFromTld(in, tldLocation); |
| } finally { |
| in.close(); |
| } |
| } |
| |
| /** |
| * Use this overload only if you already have the {@link InputStream} for some reason, otherwise use |
| * {@link #addTldLocationFromTld(TldLocation)}. |
| * |
| * @param reusedIn |
| * The stream that we already had (so we don't have to open a new one from the {@code tldLocation}). |
| */ |
| private void addTldLocationFromTld(InputStream reusedIn, TldLocation tldLocation) throws SAXException, |
| IOException { |
| String taglibUri; |
| try { |
| taglibUri = getTaglibUriFromTld(reusedIn, tldLocation.getXmlSystemId()); |
| } catch (SAXException e) { |
| LOG.error("Error while parsing TLD; skipping: " + tldLocation, e); |
| synchronized (failedTldLocations) { |
| failedTldLocations.add(tldLocation.toString()); |
| } |
| taglibUri = null; |
| } |
| if (taglibUri != null) { |
| addTldLocation(tldLocation, taglibUri); |
| } |
| } |
| |
| private void addTldLocation(TldLocation tldLocation, String taglibUri) { |
| if (tldLocations.containsKey(taglibUri)) { |
| if (LOG.isDebugEnabled()) { |
| LOG.debug("Ignored duplicate mapping of taglib URI " + StringUtil.jQuoteNoXSS(taglibUri) |
| + " to TLD location " + StringUtil.jQuoteNoXSS(tldLocation)); |
| } |
| } else { |
| tldLocations.put(taglibUri, tldLocation); |
| if (LOG.isDebugEnabled()) { |
| LOG.debug("Mapped taglib URI " + StringUtil.jQuoteNoXSS(taglibUri) |
| + " to TLD location " + StringUtil.jQuoteNoXSS(tldLocation)); |
| } |
| } |
| } |
| |
| private static Set/*<URLWithExternalForm>*/ collectMetaInfUrlsFromClassLoaders() throws IOException { |
| final Set/*<URLWithExternalForm>*/ metainfDirUrls = new TreeSet(); |
| |
| final ClassLoader tccl = tryGetThreadContextClassLoader(); |
| if (tccl != null) { |
| collectMetaInfUrlsFromClassLoader(tccl, metainfDirUrls); |
| } |
| |
| final ClassLoader cccl = TaglibFactory.class.getClassLoader(); |
| if (!isDescendantOfOrSameAs(tccl, cccl)) { |
| collectMetaInfUrlsFromClassLoader(cccl, metainfDirUrls); |
| } |
| return metainfDirUrls; |
| } |
| |
| private static void collectMetaInfUrlsFromClassLoader(ClassLoader cl, Set/* <URLWithExternalForm> */metainfDirUrls) |
| throws IOException { |
| Enumeration/*<URL>*/ urls = cl.getResources(META_INF_REL_PATH); |
| if (urls != null) { |
| while (urls.hasMoreElements()) { |
| metainfDirUrls.add(new URLWithExternalForm((URL) urls.nextElement())); |
| } |
| } |
| } |
| |
| private String getTaglibUriFromTld(InputStream tldFileIn, String tldFileXmlSystemId) throws SAXException, IOException { |
| TldParserForTaglibUriExtraction tldParser = new TldParserForTaglibUriExtraction(); |
| parseXml(tldFileIn, tldFileXmlSystemId, tldParser); |
| return tldParser.getTaglibUri(); |
| } |
| |
| /** |
| * @param tldLocation |
| * The physical location of the TLD file |
| * @param taglibUri |
| * The URI used in templates to refer to the taglib (like {@code <%@ taglib uri="..." ... %>} in JSP). |
| */ |
| private TemplateHashModel loadTaglib(TldLocation tldLocation, String taglibUri) throws IOException, SAXException { |
| if (LOG.isDebugEnabled()) { |
| LOG.debug("Loading taglib for URI " + StringUtil.jQuoteNoXSS(taglibUri) |
| + " from TLD location " + StringUtil.jQuoteNoXSS(tldLocation)); |
| } |
| final Taglib taglib = new Taglib(servletContext, tldLocation, objectWrapper); |
| taglibs.put(taglibUri, taglib); |
| tldLocations.remove(taglibUri); |
| return taglib; |
| } |
| |
| private static void parseXml(InputStream in, String systemId, DefaultHandler handler) |
| throws SAXException, IOException { |
| InputSource inSrc = new InputSource(); |
| inSrc.setSystemId(systemId); |
| inSrc.setByteStream(toCloseIgnoring(in)); |
| |
| SAXParserFactory factory = SAXParserFactory.newInstance(); |
| factory.setNamespaceAware(false); |
| factory.setValidating(false); |
| XMLReader reader; |
| try { |
| reader = factory.newSAXParser().getXMLReader(); |
| } catch (ParserConfigurationException e) { |
| // Not expected |
| throw new RuntimeException("XML parser setup failed", e); |
| } |
| reader.setEntityResolver(new LocalDtdEntityResolver()); |
| reader.setContentHandler(handler); |
| reader.setErrorHandler(handler); |
| |
| reader.parse(inSrc); |
| } |
| |
| private static String resolveRelativeUri(String uri) throws TaglibGettingException { |
| TemplateModel reqHash; |
| try { |
| reqHash = Environment.getCurrentEnvironment().getVariable( |
| FreemarkerServlet.KEY_REQUEST_PRIVATE); |
| } catch (TemplateModelException e) { |
| throw new TaglibGettingException("Failed to get FreemarkerServlet request information", e); |
| } |
| if (reqHash instanceof HttpRequestHashModel) { |
| HttpServletRequest req = |
| ((HttpRequestHashModel) reqHash).getRequest(); |
| String pi = req.getPathInfo(); |
| String reqPath = req.getServletPath(); |
| if (reqPath == null) { |
| reqPath = ""; |
| } |
| reqPath += (pi == null ? "" : pi); |
| // We don't care about paths with ".." in them. If the container |
| // wishes to resolve them on its own, let it be. |
| int lastSlash = reqPath.lastIndexOf('/'); |
| if (lastSlash != -1) { |
| return reqPath.substring(0, lastSlash + 1) + uri; |
| } else { |
| return '/' + uri; |
| } |
| } |
| throw new TaglibGettingException( |
| "Can't resolve relative URI " + uri + " as request URL information is unavailable."); |
| } |
| |
| /** |
| * Ignores attempts to close the stream. |
| */ |
| private static FilterInputStream toCloseIgnoring(InputStream in) { |
| return new FilterInputStream(in) { |
| @Override |
| public void close() { |
| // Do nothing |
| } |
| }; |
| } |
| |
| private static int getUriType(String uri) throws MalformedURLException { |
| if (uri == null) { |
| throw new IllegalArgumentException("null is not a valid URI"); |
| } |
| if (uri.length() == 0) { |
| throw new MalformedURLException("empty string is not a valid URI"); |
| } |
| final char c0 = uri.charAt(0); |
| if (c0 == '/') { |
| return URL_TYPE_ABSOLUTE; |
| } |
| // Check if it conforms to RFC 3986 3.1 in order to qualify as ABS_URI |
| if (c0 < 'a' || c0 > 'z') { // First char of scheme must be alpha |
| return URL_TYPE_RELATIVE; |
| } |
| final int colon = uri.indexOf(':'); |
| if (colon == -1) { // Must have a colon |
| return URL_TYPE_RELATIVE; |
| } |
| // Subsequent chars must be [a-z,0-9,+,-,.] |
| for (int i = 1; i < colon; ++i) { |
| final char c = uri.charAt(i); |
| if ((c < 'a' || c > 'z') && (c < '0' || c > '9') && c != '+' && c != '-' && c != '.') { |
| return URL_TYPE_RELATIVE; |
| } |
| } |
| return URL_TYPE_FULL; |
| } |
| |
| private static boolean isJarPath(final String uriPath) { |
| return uriPath.endsWith(".jar") || uriPath.endsWith(".zip"); |
| } |
| |
| private static boolean isJarUrl(URL url) { |
| final String scheme = url.getProtocol(); |
| return "jar".equals(scheme) || "zip".equals(scheme) |
| || "vfszip".equals(scheme) // JBoss AS |
| || "wsjar".equals(scheme); // WebSphere |
| } |
| |
| private static URL createJarEntryUrl(final URL jarBaseEntryUrl, String relativeEntryPath) |
| throws MalformedURLException { |
| if (relativeEntryPath.startsWith("/")) { |
| relativeEntryPath = relativeEntryPath.substring(1); |
| } |
| try { |
| return new URL(jarBaseEntryUrl, StringUtil.URLPathEnc(relativeEntryPath, PLATFORM_FILE_ENCODING)); |
| } catch (UnsupportedEncodingException e) { |
| throw new BugException(); |
| } |
| } |
| |
| /** |
| * Trying to hide any JarFile implementation inconsistencies. |
| */ |
| private static String normalizeJarEntryPath(String jarEntryDirPath, boolean directory) { |
| // Not know to be a problem, but to be in the safe side: |
| if (!jarEntryDirPath.startsWith("/")) { |
| jarEntryDirPath = "/" + jarEntryDirPath; |
| } |
| |
| // Known to be a problem: |
| if (directory && !jarEntryDirPath.endsWith("/")) { |
| jarEntryDirPath = jarEntryDirPath + "/"; |
| } |
| |
| return jarEntryDirPath; |
| } |
| |
| private static MalformedURLException newFailedToExtractEntryPathException(final URL url) { |
| return new MalformedURLException("Failed to extract jar entry path from: " + url); |
| } |
| |
| /** |
| * Converts an URL to a {@code File} object, if the URL format (scheme) makes is possible. |
| */ |
| private File urlToFileOrNull(URL url) { |
| if (test_emulateNoUrlToFileConversions) { |
| return null; |
| } |
| |
| if (!"file".equals(url.getProtocol())) { |
| return null; |
| } |
| |
| String filePath; |
| try { |
| // Using URI instead of URL, so we get an URL-decoded path. |
| filePath = url.toURI().getSchemeSpecificPart(); |
| } catch (URISyntaxException e) { // Can happen, as URI-s are stricter than legacy URL-s. |
| // URL.getFile() doesn't decode %XX-s (used for spaces and non-US-ASCII letters usually), so we do. |
| // As it was originally created for a file somewhere, we hope that it uses the platform default encoding. |
| try { |
| filePath = URLDecoder.decode(url.getFile(), PLATFORM_FILE_ENCODING); |
| } catch (UnsupportedEncodingException e2) { |
| throw new BugException(e2); |
| } |
| } |
| return new File(filePath); |
| } |
| |
| /** |
| * Gets a servlet context resource as a {@link JarFile} if possible, return {@code null} otherwise. |
| * For BC only, we try to get over errors during URL/JarFile construction, so then the caller can fall back to the |
| * legacy ZipInputStream-based approach. |
| */ |
| private JarFile servletContextResourceToFileOrNull(final String jarResourcePath) throws MalformedURLException, |
| IOException { |
| URL jarResourceUrl = servletContext.getResource(jarResourcePath); |
| if (jarResourceUrl == null) { |
| LOG.error("ServletContext resource URL was null (missing resource?): " + jarResourcePath); |
| return null; |
| } |
| |
| File jarResourceAsFile = urlToFileOrNull(jarResourceUrl); |
| if (jarResourceAsFile == null) { |
| // Expected - it's just not File |
| return null; |
| } |
| |
| if (!jarResourceAsFile.isFile()) { |
| LOG.error("Jar file doesn't exist - falling back to stream mode: " + jarResourceAsFile); |
| return null; |
| } |
| |
| return new JarFile(jarResourceAsFile); |
| } |
| |
| private static URL tryCreateServletContextJarEntryUrl( |
| ServletContext servletContext, final String servletContextJarFilePath, final String entryPath) { |
| try { |
| final URL jarFileUrl = servletContext.getResource(servletContextJarFilePath); |
| if (jarFileUrl == null) { |
| throw new IOException("Servlet context resource not found: " + servletContextJarFilePath); |
| } |
| return new URL( |
| "jar:" |
| + jarFileUrl.toURI() |
| + JAR_URL_ENTRY_PATH_START |
| + URLEncoder.encode( |
| entryPath.startsWith("/") ? entryPath.substring(1) : entryPath, |
| PLATFORM_FILE_ENCODING)); |
| } catch (Exception e) { |
| LOG.error("Couldn't get URL for serlvetContext resource " |
| + StringUtil.jQuoteNoXSS(servletContextJarFilePath) |
| + " / jar entry " + StringUtil.jQuoteNoXSS(entryPath), |
| e); |
| return null; |
| } |
| } |
| |
| private static boolean isTldFileNameIgnoreCase(String name) { |
| final int dotIdx = name.lastIndexOf('.'); |
| if (dotIdx < 0) return false; |
| final String extension = name.substring(dotIdx + 1).toLowerCase(); |
| return extension.equalsIgnoreCase("tld"); |
| } |
| |
| private static ClassLoader tryGetThreadContextClassLoader() { |
| ClassLoader tccl; |
| try { |
| tccl = Thread.currentThread().getContextClassLoader(); |
| } catch (SecurityException e) { |
| // Suppress |
| tccl = null; |
| LOG.warn("Can't access Thread Context ClassLoader", e); |
| } |
| return tccl; |
| } |
| |
| private static boolean isDescendantOfOrSameAs(ClassLoader descendant, ClassLoader parent) { |
| while (true) { |
| if (descendant == null) { |
| return false; |
| } |
| if (descendant == parent) { |
| return true; |
| } |
| descendant = descendant.getParent(); |
| } |
| } |
| |
| /** |
| * A location within which we will look for {@code META-INF/**}{@code /*.tld}-s. Used in the parameter to |
| * {@link #setMetaInfTldSources}. See concrete subclasses for more. |
| * |
| * @since 2.3.22 |
| */ |
| public static abstract class MetaInfTldSource { |
| private MetaInfTldSource() { } |
| } |
| |
| /** |
| * To search TLD-s under <tt>sevletContext:/WEB-INF/lib/*.{jar,zip}/META-INF/**</tt><tt>/*.tld</tt>, as requested by |
| * the JSP specification. Note that these also used to be in the classpath, so it's redundant to use this together |
| * with a sufficiently permissive {@link ClasspathMetaInfTldSource}. |
| * |
| * @since 2.3.22 |
| */ |
| public static final class WebInfPerLibJarMetaInfTldSource extends MetaInfTldSource { |
| public final static WebInfPerLibJarMetaInfTldSource INSTANCE = new WebInfPerLibJarMetaInfTldSource(); |
| private WebInfPerLibJarMetaInfTldSource() { }; |
| } |
| |
| /** |
| * To search TLD-s under {@code META-INF/**}{@code /*.tld} inside classpath root containers, that is, in directories |
| * and jar-s that are in the classpath (or are visible for the class loader otherwise). It will only search inside |
| * those roots whose URL matches the pattern specified in the constructor. It correctly handles when multiple roots |
| * contain a TLD with the same name (typically, {@code META-INF/taglib.tld}), that is, those TLD-s won't shadow each |
| * other, all of them will be loaded independently. |
| * |
| * <p> |
| * Note that this TLD discovery mechanism is not part of the JSP specification. |
| * |
| * @since 2.3.22 |
| */ |
| public static final class ClasspathMetaInfTldSource extends MetaInfTldSource { |
| |
| private final Pattern rootContainerPattern; |
| |
| /** |
| * @param rootContainerPattern |
| * The pattern against which the classpath root container URL-s will be matched. For example, to only |
| * search in jar-s whose name contains "taglib", the patter should be {@code ".*taglib\.jar$"}. To |
| * search everywhere, the pattern should be {@code ".*"}. The pattern need to match the whole URL, |
| * not just part of it. |
| */ |
| public ClasspathMetaInfTldSource(Pattern rootContainerPattern) { |
| this.rootContainerPattern = rootContainerPattern; |
| } |
| |
| /** |
| * See constructor argument: {@link #ClasspathMetaInfTldSource(Pattern)}. |
| */ |
| public Pattern getRootContainerPattern() { |
| return rootContainerPattern; |
| }; |
| |
| } |
| |
| /** |
| * When it occurs in the {@link MetaInfTldSource} list, all {@link MetaInfTldSource}-s before it will be disabled. |
| * This is useful when the list is assembled from multiple sources, and some want to re-start it, rather than append |
| * to the end of it. |
| * |
| * @see FreemarkerServlet#SYSTEM_PROPERTY_META_INF_TLD_SOURCES |
| * @see TaglibFactory#setMetaInfTldSources(List) |
| */ |
| public static final class ClearMetaInfTldSource extends MetaInfTldSource { |
| public final static ClearMetaInfTldSource INSTANCE = new ClearMetaInfTldSource(); |
| private ClearMetaInfTldSource() { }; |
| } |
| |
| private interface TldLocation { |
| |
| /** |
| * Reads the TLD file. |
| * @return Not {@code null} |
| */ |
| public abstract InputStream getInputStream() throws IOException; |
| |
| /** |
| * The absolute URL of the TLD file. |
| * @return Not {@code null} |
| */ |
| public abstract String getXmlSystemId() throws IOException; |
| } |
| |
| private interface InputStreamFactory { |
| InputStream getInputStream(); |
| |
| } |
| |
| private class ServletContextTldLocation implements TldLocation { |
| |
| private final String fileResourcePath; |
| |
| public ServletContextTldLocation(String fileResourcePath) { |
| this.fileResourcePath = fileResourcePath; |
| } |
| |
| public InputStream getInputStream() throws IOException { |
| final InputStream in = servletContext.getResourceAsStream(fileResourcePath); |
| if (in == null) { |
| throw newResourceNotFoundException(); |
| } |
| return in; |
| } |
| |
| public String getXmlSystemId() throws IOException { |
| final URL url = servletContext.getResource(fileResourcePath); |
| return url != null ? url.toExternalForm() : null; |
| } |
| |
| private IOException newResourceNotFoundException() { |
| return new IOException("Resource not found: servletContext:" + fileResourcePath); |
| } |
| |
| @Override |
| public final String toString() { |
| return "servletContext:" + fileResourcePath; |
| } |
| |
| } |
| |
| |
| /** |
| * Points to plain class loader resource (regardless of if in what classpath root container it's in). |
| */ |
| private static class ClasspathTldLocation implements TldLocation { |
| |
| private final String resourcePath; |
| |
| public ClasspathTldLocation(String resourcePath) { |
| if (!resourcePath.startsWith("/")) { |
| throw new IllegalArgumentException("\"resourcePath\" must start with /"); |
| } |
| this.resourcePath = resourcePath; |
| } |
| |
| @Override |
| public String toString() { |
| return "classpath:" + resourcePath; |
| } |
| |
| public InputStream getInputStream() throws IOException { |
| ClassLoader tccl = tryGetThreadContextClassLoader(); |
| if (tccl != null) { |
| final InputStream in = getClass().getResourceAsStream(resourcePath); |
| if (in != null) { |
| return in; |
| } |
| } |
| |
| final InputStream in = getClass().getResourceAsStream(resourcePath); |
| if (in == null) { |
| throw newResourceNotFoundException(); |
| } |
| return in; |
| } |
| |
| public String getXmlSystemId() throws IOException { |
| ClassLoader tccl = tryGetThreadContextClassLoader(); |
| if (tccl != null) { |
| final URL url = getClass().getResource(resourcePath); |
| if (url != null) { |
| return url.toExternalForm(); |
| } |
| } |
| |
| final URL url = getClass().getResource(resourcePath); |
| return url == null ? null : url.toExternalForm(); |
| } |
| |
| private IOException newResourceNotFoundException() { |
| return new IOException("Resource not found: classpath:" + resourcePath); |
| } |
| |
| } |
| |
| private abstract class JarEntryTldLocation implements TldLocation { |
| |
| /** |
| * Can be {@code null} if there was some technical problem, but then |
| * {@link #fallbackRawJarContentInputStreamFactory} and {@link #entryPath} will be non-{@code null} |
| */ |
| private final URL entryUrl; |
| private final InputStreamFactory fallbackRawJarContentInputStreamFactory; |
| private final String entryPath; |
| |
| public JarEntryTldLocation(URL entryUrl, InputStreamFactory fallbackRawJarContentInputStreamFactory, |
| String entryPath) { |
| if (entryUrl == null) { |
| NullArgumentException.check(fallbackRawJarContentInputStreamFactory); |
| NullArgumentException.check(entryPath); |
| } |
| |
| this.entryUrl = entryUrl; |
| this.fallbackRawJarContentInputStreamFactory = fallbackRawJarContentInputStreamFactory; |
| this.entryPath = entryPath != null ? normalizeJarEntryPath(entryPath, false) : null; |
| } |
| |
| public InputStream getInputStream() throws IOException { |
| if (entryUrl != null) { |
| try { |
| if (test_emulateJarEntryUrlOpenStreamFails) { |
| throw new RuntimeException("Test only"); |
| } |
| return entryUrl.openStream(); |
| } catch (Exception e) { |
| if (fallbackRawJarContentInputStreamFactory == null) { |
| // Java 7 (Java 6?): We could just re-throw `e` |
| if (e instanceof IOException) { |
| throw (IOException) e; |
| } |
| if (e instanceof RuntimeException) { |
| throw (RuntimeException) e; |
| } |
| throw new RuntimeException(e); |
| } |
| LOG.error("Failed to open InputStream for URL (will try fallback stream): " + entryUrl); |
| } |
| // Retry with the fallbackRawJarContentInputStreamFactory comes. |
| } |
| |
| final String entryPath; |
| if (this.entryPath != null) { |
| entryPath = this.entryPath; |
| } else { |
| if (entryUrl == null) { |
| throw new IOException("Nothing to deduce jar entry path from."); |
| } |
| String urlEF = entryUrl.toExternalForm(); |
| int sepIdx = urlEF.indexOf(JAR_URL_ENTRY_PATH_START); |
| if (sepIdx == -1) { |
| throw new IOException("Couldn't extract jar entry path from: " + urlEF); |
| } |
| entryPath = normalizeJarEntryPath( |
| URLDecoder.decode( |
| urlEF.substring(sepIdx + JAR_URL_ENTRY_PATH_START.length()), |
| PLATFORM_FILE_ENCODING), |
| false); |
| } |
| |
| InputStream rawIn = null; |
| ZipInputStream zipIn = null; |
| boolean returnedZipIn = false; |
| try { |
| rawIn = fallbackRawJarContentInputStreamFactory.getInputStream(); |
| if (rawIn == null) { |
| throw new IOException("Jar's InputStreamFactory (" + fallbackRawJarContentInputStreamFactory |
| + ") says the resource doesn't exist."); |
| } |
| zipIn = new ZipInputStream(rawIn); |
| while (true) { |
| final ZipEntry macthedJarEntry = zipIn.getNextEntry(); |
| if (macthedJarEntry == null) { |
| throw new IOException("Could not find JAR entry " + StringUtil.jQuoteNoXSS(entryPath) + "."); |
| } |
| if (entryPath.equals(normalizeJarEntryPath(macthedJarEntry.getName(), false))) { |
| returnedZipIn = true; |
| return zipIn; |
| } |
| } |
| } finally { |
| if (!returnedZipIn) { |
| if (zipIn != null) { |
| zipIn.close(); |
| } |
| if (rawIn != null) { |
| rawIn.close(); |
| } |
| } |
| } |
| } |
| |
| public String getXmlSystemId() { |
| return entryUrl != null ? entryUrl.toExternalForm() : null; |
| } |
| |
| @Override |
| public String toString() { |
| return entryUrl != null |
| ? entryUrl.toExternalForm() |
| : "jar:{" + fallbackRawJarContentInputStreamFactory + "}!" + entryPath; |
| } |
| |
| } |
| |
| private class JarEntryUrlTldLocation extends JarEntryTldLocation { |
| |
| private JarEntryUrlTldLocation(URL entryUrl, InputStreamFactory fallbackRawJarContentInputStreamFactory) { |
| super(entryUrl, fallbackRawJarContentInputStreamFactory, null); |
| } |
| |
| } |
| |
| /** |
| * Points to a file entry inside a jar, with optional {@link ZipInputStream} fallback. |
| */ |
| private class ServletContextJarEntryTldLocation extends JarEntryTldLocation { |
| |
| /** |
| * For creating instance based on the servlet context resource path of a jar. |
| * While it tries to construct and use an URL that points directly to the target entry inside the jar, it will |
| * operate even if these URL-related operations fail. |
| */ |
| private ServletContextJarEntryTldLocation(final String servletContextJarFilePath, final String entryPath) { |
| super( |
| tryCreateServletContextJarEntryUrl(servletContext, servletContextJarFilePath, entryPath), |
| new InputStreamFactory() { |
| public InputStream getInputStream() { |
| return servletContext.getResourceAsStream(servletContextJarFilePath); |
| } |
| |
| @Override |
| public String toString() { |
| return "servletContext:" + servletContextJarFilePath; |
| } |
| }, |
| entryPath); |
| } |
| |
| } |
| |
| private static class FileTldLocation implements TldLocation { |
| |
| private final File file; |
| |
| public FileTldLocation(File file) { |
| this.file = file; |
| } |
| |
| public InputStream getInputStream() throws IOException { |
| return new FileInputStream(file); |
| } |
| |
| public String getXmlSystemId() throws IOException { |
| return file.toURI().toURL().toExternalForm(); |
| } |
| |
| @Override |
| public String toString() { |
| return file.toString(); |
| } |
| |
| } |
| |
| private static final class Taglib implements TemplateHashModel { |
| private final Map tagsAndFunctions; |
| |
| Taglib(ServletContext ctx, TldLocation tldPath, ObjectWrapper wrapper) throws IOException, SAXException { |
| tagsAndFunctions = parseToTagsAndFunctions(ctx, tldPath, wrapper); |
| } |
| |
| public TemplateModel get(String key) { |
| return (TemplateModel) tagsAndFunctions.get(key); |
| } |
| |
| public boolean isEmpty() { |
| return tagsAndFunctions.isEmpty(); |
| } |
| |
| private static final Map parseToTagsAndFunctions( |
| ServletContext ctx, TldLocation tldLocation, ObjectWrapper objectWrapper) throws IOException, SAXException { |
| final TldParserForTaglibBuilding tldParser = new TldParserForTaglibBuilding(objectWrapper); |
| |
| InputStream in = tldLocation.getInputStream(); |
| try { |
| parseXml(in, tldLocation.getXmlSystemId(), tldParser); |
| } finally { |
| in.close(); |
| } |
| |
| EventForwarding eventForwarding = EventForwarding.getInstance(ctx); |
| if (eventForwarding != null) { |
| eventForwarding.addListeners(tldParser.getListeners()); |
| } else if (tldParser.getListeners().size() > 0) { |
| throw new TldParsingSAXException( |
| "Event listeners specified in the TLD could not be " + |
| " registered since the web application doesn't have a" + |
| " listener of class " + EventForwarding.class.getName() + |
| ". To remedy this, add this element to web.xml:\n" + |
| "| <listener>\n" + |
| "| <listener-class>" + EventForwarding.class.getName() + "</listener-class>\n" + |
| "| </listener>", null); |
| } |
| return tldParser.getTagsAndFunctions(); |
| } |
| } |
| |
| private class WebXmlParser extends DefaultHandler { |
| private static final String E_TAGLIB = "taglib"; |
| private static final String E_TAGLIB_LOCATION = "taglib-location"; |
| private static final String E_TAGLIB_URI = "taglib-uri"; |
| |
| private StringBuilder cDataCollector; |
| private String taglibUriCData; |
| private String taglibLocationCData; |
| private Locator locator; |
| |
| @Override |
| public void setDocumentLocator(Locator locator) { |
| this.locator = locator; |
| } |
| |
| @Override |
| public void startElement( |
| String nsuri, |
| String localName, |
| String qName, |
| Attributes atts) { |
| if (E_TAGLIB_URI.equals(qName) || E_TAGLIB_LOCATION.equals(qName)) { |
| cDataCollector = new StringBuilder(); |
| } |
| } |
| |
| @Override |
| public void characters(char[] chars, int off, int len) { |
| if (cDataCollector != null) { |
| cDataCollector.append(chars, off, len); |
| } |
| } |
| |
| @Override |
| public void endElement(String nsUri, String localName, String qName) throws TldParsingSAXException { |
| if (E_TAGLIB_URI.equals(qName)) { |
| taglibUriCData = cDataCollector.toString().trim(); |
| cDataCollector = null; |
| } else if (E_TAGLIB_LOCATION.equals(qName)) { |
| taglibLocationCData = cDataCollector.toString().trim(); |
| if (taglibLocationCData.length() == 0) { |
| throw new TldParsingSAXException("Required \"" + E_TAGLIB_URI + "\" element was missing or empty", |
| locator); |
| } |
| try { |
| if (getUriType(taglibLocationCData) == URL_TYPE_RELATIVE) { |
| taglibLocationCData = "/WEB-INF/" + taglibLocationCData; |
| } |
| } catch (MalformedURLException e) { |
| throw new TldParsingSAXException("Failed to detect URI type for: " + taglibLocationCData, locator, e); |
| } |
| cDataCollector = null; |
| } else if (E_TAGLIB.equals(qName)) { |
| addTldLocation( |
| isJarPath(taglibLocationCData) |
| ? (TldLocation) new ServletContextJarEntryTldLocation( |
| taglibLocationCData, DEFAULT_TLD_RESOURCE_PATH) |
| : (TldLocation) new ServletContextTldLocation(taglibLocationCData), |
| taglibUriCData); |
| } |
| } |
| } |
| |
| private static class TldParserForTaglibUriExtraction extends DefaultHandler { |
| private static final String E_URI = "uri"; |
| |
| private StringBuilder cDataCollector; |
| private String uri; |
| |
| TldParserForTaglibUriExtraction() { |
| } |
| |
| String getTaglibUri() { |
| return uri; |
| } |
| |
| @Override |
| public void startElement( |
| String nsuri, |
| String localName, |
| String qName, |
| Attributes atts) { |
| if (E_URI.equals(qName)) { |
| cDataCollector = new StringBuilder(); |
| } |
| } |
| |
| @Override |
| public void characters(char[] chars, int off, int len) { |
| if (cDataCollector != null) { |
| cDataCollector.append(chars, off, len); |
| } |
| } |
| |
| @Override |
| public void endElement(String nsuri, String localName, String qName) { |
| if (E_URI.equals(qName)) { |
| uri = cDataCollector.toString().trim(); |
| cDataCollector = null; |
| } |
| } |
| } |
| |
| static final class TldParserForTaglibBuilding extends DefaultHandler { |
| private static final String E_TAG = "tag"; |
| private static final String E_NAME = "name"; |
| private static final String E_TAG_CLASS = "tag-class"; |
| private static final String E_TAG_CLASS_LEGACY = "tagclass"; |
| |
| private static final String E_FUNCTION = "function"; |
| private static final String E_FUNCTION_CLASS = "function-class"; |
| private static final String E_FUNCTION_SIGNATURE = "function-signature"; |
| |
| private static final String E_LISTENER = "listener"; |
| private static final String E_LISTENER_CLASS = "listener-class"; |
| |
| private final BeansWrapper beansWrapper; |
| |
| private final Map tagsAndFunctions = new HashMap(); |
| private final List listeners = new ArrayList(); |
| |
| private Locator locator; |
| private StringBuilder cDataCollector; |
| |
| private Stack stack = new Stack(); |
| |
| private String tagNameCData; |
| private String tagClassCData; |
| private String functionNameCData; |
| private String functionClassCData; |
| private String functionSignatureCData; |
| private String listenerClassCData; |
| |
| TldParserForTaglibBuilding(ObjectWrapper wrapper) { |
| if (wrapper instanceof BeansWrapper) { |
| beansWrapper = (BeansWrapper) wrapper; |
| } else { |
| beansWrapper = null; |
| if (LOG.isWarnEnabled()) { |
| LOG.warn("Custom EL functions won't be loaded because " |
| + (wrapper == null |
| ? "no ObjectWrapper was specified for the TaglibFactory " |
| + "(via TaglibFactory.setObjectWrapper(...), exists since 2.3.22)" |
| : "the ObjectWrapper wasn't instance of " + BeansWrapper.class.getName()) |
| + "."); |
| } |
| } |
| } |
| |
| Map getTagsAndFunctions() { |
| return tagsAndFunctions; |
| } |
| |
| List getListeners() { |
| return listeners; |
| } |
| |
| @Override |
| public void setDocumentLocator(Locator locator) { |
| this.locator = locator; |
| } |
| |
| @Override |
| public void startElement(String nsUri, String localName, String qName, Attributes atts) { |
| stack.push(qName); |
| if (stack.size() == 3) { |
| if (E_NAME.equals(qName) || E_TAG_CLASS_LEGACY.equals(qName) || E_TAG_CLASS.equals(qName) |
| || E_LISTENER_CLASS.equals(qName) || E_FUNCTION_CLASS.equals(qName) |
| || E_FUNCTION_SIGNATURE.equals(qName)) { |
| cDataCollector = new StringBuilder(); |
| } |
| } |
| } |
| |
| @Override |
| public void characters(char[] chars, int off, int len) { |
| if (cDataCollector != null) { |
| cDataCollector.append(chars, off, len); |
| } |
| } |
| |
| @Override |
| public void endElement(String nsuri, String localName, String qName) throws TldParsingSAXException { |
| if (!stack.peek().equals(qName)) { |
| throw new TldParsingSAXException("Unbalanced tag nesting at \"" + qName + "\" end-tag.", locator); |
| } |
| |
| if (stack.size() == 3) { |
| if (E_NAME.equals(qName)) { |
| if (E_TAG.equals(stack.get(1))) { |
| tagNameCData = pullCData(); |
| } else if (E_FUNCTION.equals(stack.get(1))) { |
| functionNameCData = pullCData(); |
| } |
| } else if (E_TAG_CLASS_LEGACY.equals(qName) || E_TAG_CLASS.equals(qName)) { |
| tagClassCData = pullCData(); |
| } else if (E_LISTENER_CLASS.equals(qName)) { |
| listenerClassCData = pullCData(); |
| } else if (E_FUNCTION_CLASS.equals(qName)) { |
| functionClassCData = pullCData(); |
| } else if (E_FUNCTION_SIGNATURE.equals(qName)) { |
| functionSignatureCData = pullCData(); |
| } |
| } else if (stack.size() == 2) { |
| if (E_TAG.equals(qName)) { |
| checkChildElementNotNull(qName, E_NAME, tagNameCData); |
| checkChildElementNotNull(qName, E_TAG_CLASS, tagClassCData); |
| |
| final Class tagClass = resoveClassFromTLD(tagClassCData, "custom tag", tagNameCData); |
| |
| final TemplateModel impl; |
| try { |
| if (Tag.class.isAssignableFrom(tagClass)) { |
| impl = new TagTransformModel(tagNameCData, tagClass); |
| } else { |
| impl = new SimpleTagDirectiveModel(tagNameCData, tagClass); |
| } |
| } catch (IntrospectionException e) { |
| throw new TldParsingSAXException( |
| "JavaBean introspection failed on custom tag class " + tagClassCData, |
| locator, |
| e); |
| } |
| |
| tagsAndFunctions.put(tagNameCData, impl); |
| |
| tagNameCData = null; |
| tagClassCData = null; |
| } else if (E_FUNCTION.equals(qName) && beansWrapper != null) { |
| checkChildElementNotNull(qName, E_FUNCTION_CLASS, functionClassCData); |
| checkChildElementNotNull(qName, E_FUNCTION_SIGNATURE, functionSignatureCData); |
| checkChildElementNotNull(qName, E_NAME, functionNameCData); |
| |
| final Class functionClass = resoveClassFromTLD( |
| functionClassCData, "custom EL function", functionNameCData); |
| |
| final Method functionMethod; |
| try { |
| functionMethod = TaglibMethodUtil.getMethodByFunctionSignature( |
| functionClass, functionSignatureCData); |
| } catch (Exception e) { |
| throw new TldParsingSAXException( |
| "Error while trying to resolve signature " + StringUtil.jQuote(functionSignatureCData) |
| + " on class " + StringUtil.jQuote(functionClass.getName()) |
| + " for custom EL function " + StringUtil.jQuote(functionNameCData) + ".", |
| locator, |
| e); |
| } |
| |
| final int modifiers = functionMethod.getModifiers(); |
| if (!Modifier.isPublic(modifiers) || !Modifier.isStatic(modifiers)) { |
| throw new TldParsingSAXException( |
| "The custom EL function method must be public and static: " + functionMethod, |
| locator); |
| } |
| |
| final TemplateMethodModelEx methodModel; |
| try { |
| methodModel = beansWrapper.wrap(null, functionMethod); |
| } catch (Exception e) { |
| throw new TldParsingSAXException( |
| "FreeMarker object wrapping failed on method : " + functionMethod, |
| locator); |
| } |
| |
| tagsAndFunctions.put(functionNameCData, methodModel); |
| |
| functionNameCData = null; |
| functionClassCData = null; |
| functionSignatureCData = null; |
| } else if (E_LISTENER.equals(qName)) { |
| checkChildElementNotNull(qName, E_LISTENER_CLASS, listenerClassCData); |
| |
| final Class listenerClass = resoveClassFromTLD(listenerClassCData, E_LISTENER, null); |
| |
| final Object listener; |
| try { |
| listener = listenerClass.newInstance(); |
| } catch (Exception e) { |
| throw new TldParsingSAXException( |
| "Failed to create new instantiate from listener class " + listenerClassCData, |
| locator, |
| e); |
| } |
| |
| listeners.add(listener); |
| |
| listenerClassCData = null; |
| } |
| } |
| |
| stack.pop(); |
| } |
| |
| private String pullCData() { |
| String r = cDataCollector.toString().trim(); |
| cDataCollector = null; |
| return r; |
| } |
| |
| private void checkChildElementNotNull(String parentElementName, String childElementName, String value) |
| throws TldParsingSAXException { |
| if (value == null) { |
| throw new TldParsingSAXException( |
| "Missing required \"" + childElementName + "\" element inside the \"" |
| + parentElementName + "\" element.", locator); |
| } |
| } |
| |
| private Class resoveClassFromTLD(String className, String entryType, String entryName) |
| throws TldParsingSAXException { |
| try { |
| return ClassUtil.forName(className); |
| } catch (LinkageError e) { |
| throw newTLDEntryClassLoadingException(e, className, entryType, entryName); |
| } catch (ClassNotFoundException e) { |
| throw newTLDEntryClassLoadingException(e, className, entryType, entryName); |
| } |
| } |
| |
| private TldParsingSAXException newTLDEntryClassLoadingException(Throwable e, String className, |
| String entryType, String entryName) |
| throws TldParsingSAXException { |
| int dotIdx = className.lastIndexOf('.'); |
| if (dotIdx != -1) { |
| dotIdx = className.lastIndexOf('.', dotIdx - 1); |
| } |
| boolean looksLikeNestedClass = |
| dotIdx != -1 && className.length() > dotIdx + 1 |
| && Character.isUpperCase(className.charAt(dotIdx + 1)); |
| return new TldParsingSAXException( |
| (e instanceof ClassNotFoundException ? "Not found class " : "Can't load class ") |
| + StringUtil.jQuote(className) + " for " + entryType |
| + (entryName != null ? " " + StringUtil.jQuote(entryName) : "") + "." |
| + (looksLikeNestedClass |
| ? " Hint: Before nested classes, use \"$\", not \".\"." |
| : ""), |
| locator, |
| e); |
| } |
| |
| } |
| |
| private static final class LocalDtdEntityResolver implements EntityResolver { |
| |
| private static final Map DTDS = new HashMap(); |
| static |
| { |
| // JSP taglib 1.2 |
| DTDS.put("-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN", "web-jsptaglibrary_1_2.dtd"); |
| DTDS.put("http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd", "web-jsptaglibrary_1_2.dtd"); |
| // JSP taglib 1.1 |
| DTDS.put("-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN", "web-jsptaglibrary_1_1.dtd"); |
| DTDS.put("http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd", "web-jsptaglibrary_1_1.dtd"); |
| // Servlet 2.3 |
| DTDS.put("-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN", "web-app_2_3.dtd"); |
| DTDS.put("http://java.sun.com/dtd/web-app_2_3.dtd", "web-app_2_3.dtd"); |
| // Servlet 2.2 |
| DTDS.put("-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN", "web-app_2_2.dtd"); |
| DTDS.put("http://java.sun.com/j2ee/dtds/web-app_2_2.dtd", "web-app_2_2.dtd"); |
| } |
| |
| public InputSource resolveEntity(String publicId, String systemId) { |
| String resourceName = (String) DTDS.get(publicId); |
| if (resourceName == null) { |
| resourceName = (String) DTDS.get(systemId); |
| } |
| InputStream resourceStream; |
| if (resourceName != null) { |
| resourceStream = getClass().getResourceAsStream(resourceName); |
| } else { |
| // Fake an empty stream for unknown DTDs |
| resourceStream = new ByteArrayInputStream(new byte[0]); |
| } |
| InputSource is = new InputSource(resourceStream); |
| is.setPublicId(publicId); |
| is.setSystemId(systemId); |
| return is; |
| } |
| } |
| |
| /** |
| * Redefines {@code SAXParseException#toString()} and {@code SAXParseException#getCause()} because it's broken on |
| * Java 1.6 and earlier. |
| */ |
| private static class TldParsingSAXException extends SAXParseException { |
| |
| private final Throwable cause; |
| |
| TldParsingSAXException(String message, Locator locator) { |
| this(message, locator, null); |
| } |
| |
| TldParsingSAXException(String message, Locator locator, Throwable e) { |
| super(message, locator, e instanceof Exception ? (Exception) e : new Exception( |
| "Unchecked exception; see cause", e)); |
| cause = e; |
| } |
| |
| @Override |
| public String toString() { |
| StringBuilder sb = new StringBuilder(getClass().getName()); |
| sb.append(": "); |
| int startLn = sb.length(); |
| |
| String systemId = getSystemId(); |
| String publicId = getPublicId(); |
| if (systemId != null || publicId != null) { |
| sb.append("In "); |
| if (systemId != null) { |
| sb.append(systemId); |
| } |
| if (publicId != null) { |
| if (systemId != null) { |
| sb.append(" (public ID: "); |
| } |
| sb.append(publicId); |
| if (systemId != null) { |
| sb.append(')'); |
| } |
| } |
| } |
| |
| int line = getLineNumber(); |
| if (line != -1) { |
| sb.append(sb.length() != startLn ? ", at " : "At "); |
| sb.append("line "); |
| sb.append(line); |
| int col = getColumnNumber(); |
| if (col != -1) { |
| sb.append(", column "); |
| sb.append(col); |
| } |
| } |
| |
| String message = getLocalizedMessage(); |
| if (message != null) { |
| if (sb.length() != startLn) { |
| sb.append(":\n"); |
| } |
| sb.append(message); |
| } |
| |
| return sb.toString(); |
| } |
| |
| @Override |
| public Throwable getCause() { |
| Throwable superCause = super.getCause(); |
| return superCause == null ? this.cause : superCause; |
| } |
| |
| } |
| |
| private static class URLWithExternalForm implements Comparable { |
| |
| private final URL url; |
| private final String externalForm; |
| |
| public URLWithExternalForm(URL url) { |
| this.url = url; |
| this.externalForm = url.toExternalForm(); |
| } |
| |
| public URL getUrl() { |
| return url; |
| } |
| |
| public String getExternalForm() { |
| return externalForm; |
| } |
| |
| @Override |
| public int hashCode() { |
| return externalForm.hashCode(); |
| } |
| |
| @Override |
| public boolean equals(Object that) { |
| if (this == that) return true; |
| if (that == null) return false; |
| if (getClass() != that.getClass()) return false; |
| return !externalForm.equals(((URLWithExternalForm) that).externalForm); |
| } |
| |
| @Override |
| public String toString() { |
| return "URLWithExternalForm(" + externalForm + ")"; |
| } |
| |
| public int compareTo(Object that) { |
| return this.getExternalForm().compareTo(((URLWithExternalForm) that).getExternalForm()); |
| } |
| |
| } |
| |
| private static class TaglibGettingException extends Exception { |
| |
| public TaglibGettingException(String message, Throwable cause) { |
| super(message, cause); |
| } |
| |
| public TaglibGettingException(String message) { |
| super(message); |
| } |
| |
| } |
| |
| } |
