Java tutorial
/* * 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. */ /* $Id: FOURIResolver.java 1296483 2012-03-02 21:34:30Z gadams $ */ package org.apache.fop.apps; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileNotFoundException; import java.io.IOException; import java.net.MalformedURLException; import java.net.URI; import java.net.URISyntaxException; import java.net.URL; import java.net.URLConnection; import javax.xml.transform.Source; import javax.xml.transform.TransformerException; import javax.xml.transform.URIResolver; import javax.xml.transform.stream.StreamSource; import org.apache.commons.io.FileUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.xmlgraphics.util.io.Base64EncodeStream; import org.apache.xmlgraphics.util.uri.CommonURIResolver; /** * Provides FOP specific URI resolution. This is the default URIResolver * {@link FOUserAgent} will use unless overridden. * * @see javax.xml.transform.URIResolver */ public class FOURIResolver implements javax.xml.transform.URIResolver { // log private Log log = LogFactory.getLog("FOP"); /** Common URIResolver */ private CommonURIResolver commonURIResolver = new CommonURIResolver(); /** A user settable URI Resolver */ private URIResolver uriResolver = null; /** true if exceptions are to be thrown if the URIs cannot be resolved. */ private boolean throwExceptions = false; /** * Checks if the given base URL is acceptable. It also normalizes the URL. * @param base the base URL to check * @return the normalized URL * @throws MalformedURLException if there's a problem with a file URL */ public String checkBaseURL(String base) throws MalformedURLException { // replace back slash with forward slash to ensure windows file:/// URLS are supported base = base.replace('\\', '/'); if (!base.endsWith("/")) { // The behavior described by RFC 3986 regarding resolution of relative // references may be misleading for normal users: // file://path/to/resources + myResource.res -> file://path/to/myResource.res // file://path/to/resources/ + myResource.res -> file://path/to/resources/myResource.res // We assume that even when the ending slash is missing, users have the second // example in mind base += "/"; } File dir = new File(base); if (dir.isDirectory()) { return dir.toURI().toASCIIString(); } else { URI baseURI; try { baseURI = new URI(base); String scheme = baseURI.getScheme(); boolean directoryExists = true; if ("file".equals(scheme)) { dir = FileUtils.toFile(baseURI.toURL()); directoryExists = dir.isDirectory(); } if (scheme == null || !directoryExists) { String message = "base " + base + " is not a valid directory"; if (throwExceptions) { throw new MalformedURLException(message); } log.error(message); } return baseURI.toASCIIString(); } catch (URISyntaxException e) { //TODO not ideal: our base URLs are actually base URIs. throw new MalformedURLException(e.getMessage()); } } } /** * Default constructor */ public FOURIResolver() { this(false); } /** * Additional constructor * * @param throwExceptions * true if exceptions are to be thrown if the URIs cannot be * resolved. */ public FOURIResolver(boolean throwExceptions) { this.throwExceptions = throwExceptions; } /** * Handles resolve exceptions appropriately. * * @param e * the exception * @param errorStr * error string * @param strict * strict user config */ private void handleException(Exception e, String errorStr, boolean strict) throws TransformerException { if (strict) { throw new TransformerException(errorStr, e); } log.error(e.getMessage()); } /** * Called by the processor through {@link FOUserAgent} when it encounters an * uri in an external-graphic element. (see also * {@link javax.xml.transform.URIResolver#resolve(String, String)} This * resolver will allow URLs without a scheme, i.e. it assumes 'file:' as the * default scheme. It also allows relative URLs with scheme, e.g. * file:../../abc.jpg which is not strictly RFC compliant as long as the * scheme is the same as the scheme of the base URL. If the base URL is null * a 'file:' URL referencing the current directory is used as the base URL. * If the method is successful it will return a Source of type * {@link javax.xml.transform.stream.StreamSource} with its SystemID set to * the resolved URL used to open the underlying InputStream. * * @param href * An href attribute, which may be relative or absolute. * @param base * The base URI against which the first argument will be made * absolute if the absolute URI is required. * @return A {@link javax.xml.transform.Source} object, or null if the href * cannot be resolved. * @throws javax.xml.transform.TransformerException * Never thrown by this implementation. * @see javax.xml.transform.URIResolver#resolve(String, String) */ public Source resolve(String href, String base) throws TransformerException { Source source = null; // data URLs can be quite long so evaluate early and don't try to build a File // (can lead to problems) source = commonURIResolver.resolve(href, base); // Custom uri resolution if (source == null && uriResolver != null) { source = uriResolver.resolve(href, base); } // Fallback to default resolution mechanism if (source == null) { URL absoluteURL = null; int hashPos = href.indexOf('#'); String fileURL; String fragment; if (hashPos >= 0) { fileURL = href.substring(0, hashPos); fragment = href.substring(hashPos); } else { fileURL = href; fragment = null; } File file = new File(fileURL); if (file.canRead() && file.isFile()) { try { if (fragment != null) { absoluteURL = new URL(file.toURI().toURL().toExternalForm() + fragment); } else { absoluteURL = file.toURI().toURL(); } } catch (MalformedURLException mfue) { handleException(mfue, "Could not convert filename '" + href + "' to URL", throwExceptions); } } else { // no base provided if (base == null) { // We don't have a valid file protocol based URL try { absoluteURL = new URL(href); } catch (MalformedURLException mue) { try { // the above failed, we give it another go in case // the href contains only a path then file: is // assumed absoluteURL = new URL("file:" + href); } catch (MalformedURLException mfue) { handleException(mfue, "Error with URL '" + href + "'", throwExceptions); } } // try and resolve from context of base } else { URL baseURL = null; try { baseURL = new URL(base); } catch (MalformedURLException mfue) { handleException(mfue, "Error with base URL '" + base + "'", throwExceptions); } /* * This piece of code is based on the following statement in * RFC2396 section 5.2: * * 3) If the scheme component is defined, indicating that * the reference starts with a scheme name, then the * reference is interpreted as an absolute URI and we are * done. Otherwise, the reference URI's scheme is inherited * from the base URI's scheme component. * * Due to a loophole in prior specifications [RFC1630], some * parsers allow the scheme name to be present in a relative * URI if it is the same as the base URI scheme. * Unfortunately, this can conflict with the correct parsing * of non-hierarchical URI. For backwards compatibility, an * implementation may work around such references by * removing the scheme if it matches that of the base URI * and the scheme is known to always use the <hier_part> * syntax. * * The URL class does not implement this work around, so we * do. */ assert (baseURL != null); String scheme = baseURL.getProtocol() + ":"; if (href.startsWith(scheme) && "file:".equals(scheme)) { href = href.substring(scheme.length()); int colonPos = href.indexOf(':'); int slashPos = href.indexOf('/'); if (slashPos >= 0 && colonPos >= 0 && colonPos < slashPos) { href = "/" + href; // Absolute file URL doesn't // have a leading slash } } try { absoluteURL = new URL(baseURL, href); } catch (MalformedURLException mfue) { handleException(mfue, "Error with URL; base '" + base + "' " + "href '" + href + "'", throwExceptions); } } } if (absoluteURL != null) { String effURL = absoluteURL.toExternalForm(); try { URLConnection connection = absoluteURL.openConnection(); connection.setAllowUserInteraction(false); connection.setDoInput(true); updateURLConnection(connection, href); connection.connect(); return new StreamSource(connection.getInputStream(), effURL); } catch (FileNotFoundException fnfe) { // Note: This is on "debug" level since the caller is // supposed to handle this log.debug("File not found: " + effURL); } catch (java.io.IOException ioe) { log.error("Error with opening URL '" + effURL + "': " + ioe.getMessage()); } } } return source; } /** * This method allows you to set special values on a URLConnection just * before the connect() method is called. Subclass FOURIResolver and * override this method to do things like adding the user name and password * for HTTP basic authentication. * * @param connection * the URLConnection instance * @param href * the original URI */ protected void updateURLConnection(URLConnection connection, String href) { // nop } /** * This is a convenience method for users who want to override * updateURLConnection for HTTP basic authentication. Simply call it using * the right username and password. * * @param connection * the URLConnection to set up for HTTP basic authentication * @param username * the username * @param password * the password */ protected void applyHttpBasicAuthentication(URLConnection connection, String username, String password) { String combined = username + ":" + password; try { ByteArrayOutputStream baout = new ByteArrayOutputStream(combined.length() * 2); Base64EncodeStream base64 = new Base64EncodeStream(baout); // TODO Not sure what charset/encoding can be used with basic // authentication base64.write(combined.getBytes("UTF-8")); base64.close(); connection.setRequestProperty("Authorization", "Basic " + new String(baout.toByteArray(), "UTF-8")); } catch (IOException e) { // won't happen. We're operating in-memory. throw new RuntimeException("Error during base64 encodation of username/password"); } } /** * Sets the custom URI Resolver. It is used for resolving factory-level URIs like * hyphenation patterns and as backup for URI resolution performed during a * rendering run. * * @param resolver * the new URI resolver */ public void setCustomURIResolver(URIResolver resolver) { this.uriResolver = resolver; } /** * Returns the custom URI Resolver. * * @return the URI Resolver or null, if none is set */ public URIResolver getCustomURIResolver() { return this.uriResolver; } /** * @param throwExceptions * Whether or not to throw exceptions on resolution error */ public void setThrowExceptions(boolean throwExceptions) { this.throwExceptions = throwExceptions; } }