java/org/apache/tomcat/util/buf/UriUtil.java - tomcat - Git at Google

 /*
  *  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 org.apache.tomcat.util.buf;

 import java.io.File;
 import java.io.IOException;
 import java.net.MalformedURLException;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.net.URL;
 import java.util.regex.Pattern;

 /**
  * Utility class for working with URIs and URLs.
  */
 public final class UriUtil {

     private static final char[] HEX =
             { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };

     private static final Pattern PATTERN_EXCLAMATION_MARK = Pattern.compile("!/");
     private static final Pattern PATTERN_ASTERISK = Pattern.compile("\\*/");
     private static final Pattern PATTERN_CUSTOM;
     private static final String REPLACE_CUSTOM;

     private static final String WAR_SEPARATOR;

     static {
         String custom = System.getProperty("org.apache.tomcat.util.buf.UriUtil.WAR_SEPARATOR");
         if (custom == null) {
             WAR_SEPARATOR = "*/";
             PATTERN_CUSTOM = null;
             REPLACE_CUSTOM = null;
         } else {
             WAR_SEPARATOR = custom + "/";
             PATTERN_CUSTOM = Pattern.compile(Pattern.quote(WAR_SEPARATOR));
             StringBuilder sb = new StringBuilder(custom.length() * 3);
             // Deliberately use the platform's default encoding
             byte[] ba = custom.getBytes();
             for (byte toEncode : ba) {
                 // Converting each byte in the buffer
                 sb.append('%');
                 int low = toEncode & 0x0f;
                 int high = (toEncode & 0xf0) >> 4;
                 sb.append(HEX[high]);
                 sb.append(HEX[low]);
             }
             REPLACE_CUSTOM = sb.toString();
         }
     }


     private UriUtil() {
         // Utility class. Hide default constructor
     }


     /**
      * Determine if the character is allowed in the scheme of a URI. See RFC 2396, Section 3.1
      *
      * @param c The character to test
      *
      * @return {@code true} if the character is allowed, otherwise {@code
      *         false}
      */
     private static boolean isSchemeChar(char c) {
         return Character.isLetterOrDigit(c) || c == '+' || c == '-' || c == '.';
     }


     /**
      * Determine if a URI string has a <code>scheme</code> component.
      *
      * @param uri The URI to test
      *
      * @return {@code true} if a scheme is present, otherwise {code @false}
      */
     public static boolean hasScheme(CharSequence uri) {
         int len = uri.length();
         for (int i = 0; i < len; i++) {
             char c = uri.charAt(i);
             if (c == ':') {
                 return i > 0;
             } else if (!isSchemeChar(c)) {
                 return false;
             }
         }
         return false;
     }


     public static URL buildJarUrl(File jarFile) throws IOException {
         return buildJarUrl(jarFile, null);
     }


     public static URL buildJarUrl(File jarFile, String entryPath) throws IOException {
         return buildJarUrl(jarFile.toURI().toString(), entryPath);
     }


     public static URL buildJarUrl(String fileUrlString) throws IOException {
         return buildJarUrl(fileUrlString, null);
     }


     public static URL buildJarUrl(String fileUrlString, String entryPath) throws IOException {
         String safeString = makeSafeForJarUrl(fileUrlString);
         StringBuilder sb = new StringBuilder();
         sb.append(safeString);
         sb.append("!/");
         if (entryPath != null) {
             sb.append(makeSafeForJarUrl(entryPath));
         }
         URI uri;
         try {
             // Have to use the single argument constructor as that is the only one that doesn't escape input.
             uri = new URI("jar:" + sb.toString());
         } catch (URISyntaxException e) {
             throw new IOException(e);
         }
         return uri.toURL();
     }


     public static URL buildJarSafeUrl(File file) throws IOException {
         String safe = makeSafeForJarUrl(file.toURI().toString());
         URI uri;
         try {
             uri = new URI(safe);
         } catch (URISyntaxException e) {
             throw new IOException(e);
         }
         return uri.toURL();
     }


     /*
      * When testing on markt's desktop each iteration was taking ~1420ns when using String.replaceAll().
      *
      * Switching the implementation to use pre-compiled patterns and Pattern.matcher(input).replaceAll(replacement)
      * reduced this by ~10%.
      *
      * Note: Given the very small absolute time of a single iteration, even for a web application with 1000 JARs this is
      * only going to add ~3ms. It is therefore unlikely that further optimisation will be necessary.
      */
     /*
      * Pulled out into a separate method in case we need to handle other unusual sequences in the future.
      */
     private static String makeSafeForJarUrl(String input) {
         // Since "!/" has a special meaning in a JAR URL, make sure that the
         // sequence is properly escaped if present.
         String tmp = PATTERN_EXCLAMATION_MARK.matcher(input).replaceAll("%21/");
         // Tomcat's custom jar:war: URL handling treats */ as special
         tmp = PATTERN_ASTERISK.matcher(tmp).replaceAll("%2a/");
         if (PATTERN_CUSTOM != null) {
             tmp = PATTERN_CUSTOM.matcher(tmp).replaceAll(REPLACE_CUSTOM);
         }
         return tmp;
     }


     /**
      * Convert a URL of the form <code>war:file:...</code> to <code>jar:file:...</code>.
      *
      * @param warUrl The WAR URL to convert
      *
      * @return The equivalent JAR URL
      *
      * @throws IOException If the conversion fails
      */
     public static URL warToJar(URL warUrl) throws IOException {
         // Assumes that the spec is absolute and starts war:file:/...
         String file = warUrl.getFile();
         if (file.contains("*/")) {
             file = file.replaceFirst("\\*/", "!/");
         } else if (PATTERN_CUSTOM != null) {
             file = file.replaceFirst(PATTERN_CUSTOM.pattern(), "!/");
         }
         URI uri;
         try {
             uri = new URI("jar", file, null);
         } catch (URISyntaxException e) {
             throw new IOException(e);
         }
         return uri.toURL();
     }


     public static String getWarSeparator() {
         return WAR_SEPARATOR;
     }


     /**
      * Does the provided path start with <code>file:/</code> or <code>&lt;protocol&gt;://</code>.
      *
      * @param path The path to test
      *
      * @return {@code true} if the supplied path starts with one of the recognised sequences.
      */
     public static boolean isAbsoluteURI(String path) {
         // Special case as only a single /
         if (path.startsWith("file:/")) {
             return true;
         }

         // Start at the beginning of the path and skip over any valid protocol
         // characters
         int i = 0;
         while (i < path.length() && isSchemeChar(path.charAt(i))) {
             i++;
         }
         // Need at least one protocol character. False positives with Windows
         // drives such as C:/... will be caught by the later test for "://"
         if (i == 0) {
             return false;
         }
         // path starts with something that might be a protocol. Look for a
         // following "://"
         return i + 2 < path.length() && path.charAt(i++) == ':' && path.charAt(i++) == '/' && path.charAt(i) == '/';
     }


     /**
      * Replicates the behaviour of {@link URI#resolve(String)} and adds support for URIs of the form
      * {@code jar:file:/... }.
      *
      * @param base   The base URI to resolve against
      * @param target The path to resolve
      *
      * @return The resulting URI as per {@link URI#resolve(String)}
      *
      * @throws MalformedURLException If the base URI cannot be converted to a URL
      * @throws URISyntaxException    If the resulting URL cannot be converted to a URI
      */
     public static URI resolve(URI base, String target) throws MalformedURLException, URISyntaxException {
         if (base.getScheme().equals("jar")) {
             /*
              * Previously used: new URL(base.toURL(), target).toURI() This delegated the work to the jar stream handler
              * which correctly resolved the target against the base.
              *
              * Deprecation of all the URL constructors mean a different approach is required.
              */
             URI fileUri = new URI(base.getSchemeSpecificPart());
             URI fileUriResolved = fileUri.resolve(target);

             return new URI("jar:" + fileUriResolved.toString());
         } else {
             return base.resolve(target);
         }
     }
 }
	/*
	* 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 org.apache.tomcat.util.buf;

	import java.io.File;
	import java.io.IOException;
	import java.net.MalformedURLException;
	import java.net.URI;
	import java.net.URISyntaxException;
	import java.net.URL;
	import java.util.regex.Pattern;

	/**
	* Utility class for working with URIs and URLs.
	*/
	public final class UriUtil {

	private static final char[] HEX =
	{ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };

	private static final Pattern PATTERN_EXCLAMATION_MARK = Pattern.compile("!/");
	private static final Pattern PATTERN_ASTERISK = Pattern.compile("\\*/");
	private static final Pattern PATTERN_CUSTOM;
	private static final String REPLACE_CUSTOM;

	private static final String WAR_SEPARATOR;

	static {
	String custom = System.getProperty("org.apache.tomcat.util.buf.UriUtil.WAR_SEPARATOR");
	if (custom == null) {
	WAR_SEPARATOR = "*/";
	PATTERN_CUSTOM = null;
	REPLACE_CUSTOM = null;
	} else {
	WAR_SEPARATOR = custom + "/";
	PATTERN_CUSTOM = Pattern.compile(Pattern.quote(WAR_SEPARATOR));
	StringBuilder sb = new StringBuilder(custom.length() * 3);
	// Deliberately use the platform's default encoding
	byte[] ba = custom.getBytes();
	for (byte toEncode : ba) {
	// Converting each byte in the buffer
	sb.append('%');
	int low = toEncode & 0x0f;
	int high = (toEncode & 0xf0) >> 4;
	sb.append(HEX[high]);
	sb.append(HEX[low]);
	}
	REPLACE_CUSTOM = sb.toString();
	}
	}


	private UriUtil() {
	// Utility class. Hide default constructor
	}


	/**
	* Determine if the character is allowed in the scheme of a URI. See RFC 2396, Section 3.1
	*
	* @param c The character to test
	*
	* @return {@code true} if the character is allowed, otherwise {@code
	* false}
	*/
	private static boolean isSchemeChar(char c) {
	return Character.isLetterOrDigit(c) \|\| c == '+' \|\| c == '-' \|\| c == '.';
	}


	/**
	* Determine if a URI string has a <code>scheme</code> component.
	*
	* @param uri The URI to test
	*
	* @return {@code true} if a scheme is present, otherwise {code @false}
	*/
	public static boolean hasScheme(CharSequence uri) {
	int len = uri.length();
	for (int i = 0; i < len; i++) {
	char c = uri.charAt(i);
	if (c == ':') {
	return i > 0;
	} else if (!isSchemeChar(c)) {
	return false;
	}
	}
	return false;
	}


	public static URL buildJarUrl(File jarFile) throws IOException {
	return buildJarUrl(jarFile, null);
	}


	public static URL buildJarUrl(File jarFile, String entryPath) throws IOException {
	return buildJarUrl(jarFile.toURI().toString(), entryPath);
	}


	public static URL buildJarUrl(String fileUrlString) throws IOException {
	return buildJarUrl(fileUrlString, null);
	}


	public static URL buildJarUrl(String fileUrlString, String entryPath) throws IOException {
	String safeString = makeSafeForJarUrl(fileUrlString);
	StringBuilder sb = new StringBuilder();
	sb.append(safeString);
	sb.append("!/");
	if (entryPath != null) {
	sb.append(makeSafeForJarUrl(entryPath));
	}
	URI uri;
	try {
	// Have to use the single argument constructor as that is the only one that doesn't escape input.
	uri = new URI("jar:" + sb.toString());
	} catch (URISyntaxException e) {
	throw new IOException(e);
	}
	return uri.toURL();
	}


	public static URL buildJarSafeUrl(File file) throws IOException {
	String safe = makeSafeForJarUrl(file.toURI().toString());
	URI uri;
	try {
	uri = new URI(safe);
	} catch (URISyntaxException e) {
	throw new IOException(e);
	}
	return uri.toURL();
	}


	/*
	* When testing on markt's desktop each iteration was taking ~1420ns when using String.replaceAll().
	*
	* Switching the implementation to use pre-compiled patterns and Pattern.matcher(input).replaceAll(replacement)
	* reduced this by ~10%.
	*
	* Note: Given the very small absolute time of a single iteration, even for a web application with 1000 JARs this is
	* only going to add ~3ms. It is therefore unlikely that further optimisation will be necessary.
	*/
	/*
	* Pulled out into a separate method in case we need to handle other unusual sequences in the future.
	*/
	private static String makeSafeForJarUrl(String input) {
	// Since "!/" has a special meaning in a JAR URL, make sure that the
	// sequence is properly escaped if present.
	String tmp = PATTERN_EXCLAMATION_MARK.matcher(input).replaceAll("%21/");
	// Tomcat's custom jar:war: URL handling treats */ as special
	tmp = PATTERN_ASTERISK.matcher(tmp).replaceAll("%2a/");
	if (PATTERN_CUSTOM != null) {
	tmp = PATTERN_CUSTOM.matcher(tmp).replaceAll(REPLACE_CUSTOM);
	}
	return tmp;
	}


	/**
	* Convert a URL of the form <code>war:file:...</code> to <code>jar:file:...</code>.
	*
	* @param warUrl The WAR URL to convert
	*
	* @return The equivalent JAR URL
	*
	* @throws IOException If the conversion fails
	*/
	public static URL warToJar(URL warUrl) throws IOException {
	// Assumes that the spec is absolute and starts war:file:/...
	String file = warUrl.getFile();
	if (file.contains("*/")) {
	file = file.replaceFirst("\\*/", "!/");
	} else if (PATTERN_CUSTOM != null) {
	file = file.replaceFirst(PATTERN_CUSTOM.pattern(), "!/");
	}
	URI uri;
	try {
	uri = new URI("jar", file, null);
	} catch (URISyntaxException e) {
	throw new IOException(e);
	}
	return uri.toURL();
	}


	public static String getWarSeparator() {
	return WAR_SEPARATOR;
	}


	/**
	* Does the provided path start with <code>file:/</code> or <code><protocol>://</code>.
	*
	* @param path The path to test
	*
	* @return {@code true} if the supplied path starts with one of the recognised sequences.
	*/
	public static boolean isAbsoluteURI(String path) {
	// Special case as only a single /
	if (path.startsWith("file:/")) {
	return true;
	}

	// Start at the beginning of the path and skip over any valid protocol
	// characters
	int i = 0;
	while (i < path.length() && isSchemeChar(path.charAt(i))) {
	i++;
	}
	// Need at least one protocol character. False positives with Windows
	// drives such as C:/... will be caught by the later test for "://"
	if (i == 0) {
	return false;
	}
	// path starts with something that might be a protocol. Look for a
	// following "://"
	return i + 2 < path.length() && path.charAt(i++) == ':' && path.charAt(i++) == '/' && path.charAt(i) == '/';
	}


	/**
	* Replicates the behaviour of {@link URI#resolve(String)} and adds support for URIs of the form
	* {@code jar:file:/... }.
	*
	* @param base The base URI to resolve against
	* @param target The path to resolve
	*
	* @return The resulting URI as per {@link URI#resolve(String)}
	*
	* @throws MalformedURLException If the base URI cannot be converted to a URL
	* @throws URISyntaxException If the resulting URL cannot be converted to a URI
	*/
	public static URI resolve(URI base, String target) throws MalformedURLException, URISyntaxException {
	if (base.getScheme().equals("jar")) {
	/*
	* Previously used: new URL(base.toURL(), target).toURI() This delegated the work to the jar stream handler
	* which correctly resolved the target against the base.
	*
	* Deprecation of all the URL constructors mean a different approach is required.
	*/
	URI fileUri = new URI(base.getSchemeSpecificPart());
	URI fileUriResolved = fileUri.resolve(target);

	return new URI("jar:" + fileUriResolved.toString());
	} else {
	return base.resolve(target);
	}
	}
	}