fr.cenotelie.commons.utils.http.URIUtils Maven / Gradle / Ivy
/*******************************************************************************
* Copyright (c) 2016 Association Cénotélie (cenotelie.fr)
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation, either version 3
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General
* Public License along with this program.
* If not, see output = getSegments(path);
StringBuilder result = new StringBuilder();
for (int i = 0; i != output.size(); i++) {
if (i != 0)
result.append("/");
result.append(output.get(i));
}
return result.toString();
}
/**
* Gets the segments in the specified path, with the dot segments resolved
*
* @param path The path
* @return The segments
*/
public static List getSegments(String path) {
if (path == null)
return new ArrayList<>();
if (path.isEmpty())
return new ArrayList<>();
boolean isAbsolute = path.startsWith("/");
List input = splitSegments(path);
Stack output = new Stack<>();
for (int i = 0; i != input.size(); i++) {
String head = input.get(i);
if ("..".equals(head)) {
if (output.isEmpty())
continue;
if (isAbsolute && output.size() == 1 && output.get(0).isEmpty())
// cannot remove the first empty segment for absolute paths
continue;
output.pop();
if (i == input.size() - 1)
// the last one, to not lose the trailing / push an empty segment
output.push("");
} else if (".".equals(head)) {
if (i == input.size() - 1)
// the last one, to not lose the trailing / push an empty segment
output.push("");
} else {
output.push(head);
}
}
return output;
}
/**
* Splits the path component of an URI into segments
* This method leaves empty segments at the beginning (resp. end) when the path begins (resp. ends) with a /, as well as in the middle
*
* @param path The path component of an URI
* @return The list of segments
*/
private static List splitSegments(String path) {
List result = new ArrayList<>();
int start = 0;
int index = path.indexOf("/");
while (index != -1) {
if (start == index)
result.add("");
else
result.add(path.substring(start, index));
start = index + 1;
if (start == path.length()) {
result.add("");
return result;
}
index = path.indexOf("/", start);
}
if (start < path.length())
result.add(path.substring(start));
return result;
}
/**
* Merges the paths components of two URIs
* Implements the RFC 3986 merge paths algorithm
* (See RFC 3986 - 5.2.3)
*
* @param baseAuthority The authority component of the base URI
* @param basePath The path component of the base URI
* @param refPath The path component of the reference URI
* @return The merged target path
*/
private static String mergePaths(String baseAuthority, String basePath, String refPath) {
if (baseAuthority != null && (basePath == null || basePath.isEmpty())) {
return "/" + refPath;
} else if (basePath == null || basePath.isEmpty()) {
return refPath;
} else {
int index = basePath.lastIndexOf("/");
if (index == -1)
return refPath;
return basePath.substring(0, index + 1) + refPath;
}
}
/**
* Determines whether the specified URI only contains valid characters.
* This method does the check whether the URI is well-formed
*
* @param uri An URI
* @return true if the URI only contains valid characters
*/
public static boolean allLegalCharacters(String uri) {
for (int i = 0; i != uri.length(); i++)
if (!isLegalCharacter(uri.charAt(i)))
return false;
return true;
}
/**
* Determines whether the specified character is a valid character in an URI
*
* @param c A character
* @return true if the character is valid
*/
private static boolean isLegalCharacter(char c) {
return (!Character.isWhitespace(c) && !Character.isISOControl(c) && c != '<' && c != '>');
}
/**
* Encodes an URI component
*
* @param original The original value
* @return The encoded value
*/
public static String encodeComponent(String original) {
if (original == null)
return null;
if (original.isEmpty())
return original;
StringBuilder builder = new StringBuilder();
for (int i = 0; i != original.length(); i++) {
char c = original.charAt(i);
if (Character.isHighSurrogate(c)) {
String sub = original.substring(i, i + 2);
byte[] bytes = sub.getBytes(IOUtils.UTF8);
for (int j = 0; j != bytes.length; j++) {
int n = (int) bytes[j] & 0xff;
builder.append("%");
if (n < 0x10) {
builder.append("0");
}
builder.append(Integer.toString(n, 16));
}
i++;
} else if (c == '-' || c == '_' || c == '.' || c == '!' || c == '~' || c == '*' || c == '\'' || c == '(' || c == ')' || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')) {
builder.append(c);
} else {
byte[] bytes = Character.toString(c).getBytes(IOUtils.UTF8);
for (int j = 0; j != bytes.length; j++) {
int n = (int) bytes[j] & 0xff;
builder.append("%");
if (n < 0x10) {
builder.append("0");
}
builder.append(Integer.toString(n, 16));
}
}
}
return builder.toString();
}
/**
* Decodes an URI component
*
* @param original The original value
* @return The decoded value
*/
public static String decodeComponent(String original) {
if (original == null)
return null;
if (original.isEmpty())
return original;
StringBuilder builder = new StringBuilder();
for (int i = 0; i != original.length(); i++) {
char c = original.charAt(i);
if (c == '+') {
builder.append(' ');
continue;
} else if (c != '%') {
builder.append(c);
continue;
}
if (original.length() < i + 3)
continue;
int b0 = Integer.parseInt(original.substring(i + 1, i + 3), 16);
if ((b0 & 0x80) == 0x00) {
// 0xxxxxxx - one byte UTF-8
builder.append(new String(new byte[]{(byte) b0}, IOUtils.UTF8));
i += 2;
} else if ((b0 & 0xE0) == 0xC0) {
// 110xxxxx - two bytes UTF-8
if (original.length() < i + 6)
continue;
int b1 = Integer.parseInt(original.substring(i + 4, i + 6), 16);
builder.append(new String(new byte[]{(byte) b0, (byte) b1}, IOUtils.UTF8));
i += 5;
} else if ((b0 & 0xF0) == 0xE0) {
// 1110xxxx - three bytes UTF-8
if (original.length() < i + 9)
continue;
int b1 = Integer.parseInt(original.substring(i + 4, i + 6), 16);
int b2 = Integer.parseInt(original.substring(i + 7, i + 9), 16);
builder.append(new String(new byte[]{(byte) b0, (byte) b1, (byte) b2}, IOUtils.UTF8));
i += 8;
} else if ((b0 & 0xF8) == 0xF0) {
// 11110xxx - four bytes UTF-8
if (original.length() < i + 12)
continue;
int b1 = Integer.parseInt(original.substring(i + 4, i + 6), 16);
int b2 = Integer.parseInt(original.substring(i + 7, i + 9), 16);
int b3 = Integer.parseInt(original.substring(i + 10, i + 12), 16);
builder.append(new String(new byte[]{(byte) b0, (byte) b1, (byte) b2, (byte) b3}, IOUtils.UTF8));
i += 11;
}
}
return builder.toString();
}
/**
* Gets the sanitized single value of a parameter
*
* @param values The current values
* @return The single value, or null if there is none
*/
public static String getSingleParameter(String[] values) {
if (values == null)
return null;
if (values.length == 0)
return null;
String value = values[0].trim();
if (value.isEmpty())
return null;
return value;
}
/**
* Gets the sanitized multi values of a parameter
*
* @param values The current values
* @return The values
*/
public static String[] getMultiParameters(String[] values) {
if (values == null)
return new String[0];
if (values.length == 0)
return values;
int count = 0;
for (int i = 0; i != values.length; i++) {
values[i] = values[i].trim();
if (!values[i].isEmpty())
count++;
}
if (count == values.length)
return values;
String[] result = new String[count];
int index = 0;
for (int i = 0; i != values.length; i++) {
if (!values[i].isEmpty())
result[index++] = values[i];
}
return result;
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy