/*
* 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);
}
}
}