/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.jf.util;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.io.*;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.IntBuffer;
import java.util.Collection;
import java.util.regex.Pattern;
/**
* This class handles the complexities of translating a class name into a file name. i.e. dealing with case insensitive
* file systems, windows reserved filenames, class names with extremely long package/class elements, etc.
*
* The types of transformations this class does include:
* - append a '#123' style numeric suffix if 2 physical representations collide
* - replace some number of characters in the middle with a '#' character name if an individual path element is too long
* - append a '#' if an individual path element would otherwise be considered a reserved filename
*/
public class ClassFileNameHandler {
private static final int MAX_FILENAME_LENGTH = 255;
// How many characters to reserve in the physical filename for numeric suffixes
// Dex files can currently only have 64k classes, so 5 digits plus 1 for an '#' should
// be sufficient to handle the case when every class has a conflicting name
private static final int NUMERIC_SUFFIX_RESERVE = 6;
private final int NO_VALUE = -1;
private final int CASE_INSENSITIVE = 0;
private final int CASE_SENSITIVE = 1;
private int forcedCaseSensitivity = NO_VALUE;
private DirectoryEntry top;
private String fileExtension;
private boolean modifyWindowsReservedFilenames;
public ClassFileNameHandler(File path, String fileExtension) {
this.top = new DirectoryEntry(path);
this.fileExtension = fileExtension;
this.modifyWindowsReservedFilenames = isWindows();
}
// for testing
public ClassFileNameHandler(File path, String fileExtension, boolean caseSensitive,
boolean modifyWindowsReservedFilenames) {
this.top = new DirectoryEntry(path);
this.fileExtension = fileExtension;
this.forcedCaseSensitivity = caseSensitive?CASE_SENSITIVE:CASE_INSENSITIVE;
this.modifyWindowsReservedFilenames = modifyWindowsReservedFilenames;
}
private int getMaxFilenameLength() {
return MAX_FILENAME_LENGTH - NUMERIC_SUFFIX_RESERVE;
}
public File getUniqueFilenameForClass(String className) {
//class names should be passed in the normal dalvik style, with a leading L, a trailing ;, and using
//'/' as a separator.
if (className.charAt(0) != 'L' || className.charAt(className.length()-1) != ';') {
throw new RuntimeException("Not a valid dalvik class name");
}
int packageElementCount = 1;
for (int i=1; i<className.length()-1; i++) {
if (className.charAt(i) == '/') {
packageElementCount++;
}
}
String[] packageElements = new String[packageElementCount];
int elementIndex = 0;
int elementStart = 1;
for (int i=1; i<className.length()-1; i++) {
if (className.charAt(i) == '/') {
//if the first char after the initial L is a '/', or if there are
//two consecutive '/'
if (i-elementStart==0) {
throw new RuntimeException("Not a valid dalvik class name");
}
packageElements[elementIndex++] = className.substring(elementStart, i);
elementStart = ++i;
}
}
//at this point, we have added all the package elements to packageElements, but still need to add
//the final class name. elementStart should point to the beginning of the class name
//this will be true if the class ends in a '/', i.e. Lsome/package/className/;
if (elementStart >= className.length()-1) {
throw new RuntimeException("Not a valid dalvik class name");
}
packageElements[elementIndex] = className.substring(elementStart, className.length()-1);
return addUniqueChild(top, packageElements, 0);
}
@Nonnull
private File addUniqueChild(@Nonnull DirectoryEntry parent, @Nonnull String[] packageElements,
int packageElementIndex) {
if (packageElementIndex == packageElements.length - 1) {
FileEntry fileEntry = new FileEntry(parent, packageElements[packageElementIndex] + fileExtension);
parent.addChild(fileEntry);
String physicalName = fileEntry.getPhysicalName();
// the physical name should be set when adding it as a child to the parent
assert physicalName != null;
return new File(parent.file, physicalName);
} else {
DirectoryEntry directoryEntry = new DirectoryEntry(parent, packageElements[packageElementIndex]);
directoryEntry = (DirectoryEntry)parent.addChild(directoryEntry);
return addUniqueChild(directoryEntry, packageElements, packageElementIndex+1);
}
}
private static int utf8Length(String str) {
int utf8Length = 0;
int i=0;
while (i<str.length()) {
int c = str.codePointAt(i);
utf8Length += utf8Length(c);
i += Character.charCount(c);
}
return utf8Length;
}
private static int utf8Length(int codePoint) {
if (codePoint < 0x80) {
return 1;
} else if (codePoint < 0x800) {
return 2;
} else if (codePoint < 0x10000) {
return 3;
} else {
return 4;
}
}
/**
* Shortens an individual file/directory name, removing the necessary number of code points
* from the middle of the string such that the utf-8 encoding of the string is at least
* bytesToRemove bytes shorter than the original.
*
* The removed codePoints in the middle of the string will be replaced with a # character.
*/
@Nonnull
static String shortenPathComponent(@Nonnull String pathComponent, int bytesToRemove) {
// We replace the removed part with a #, so we need to remove 1 extra char
bytesToRemove++;
int[] codePoints;
try {
IntBuffer intBuffer = ByteBuffer.wrap(pathComponent.getBytes("UTF-32BE")).asIntBuffer();
codePoints = new int[intBuffer.limit()];
intBuffer.get(codePoints);
} catch (UnsupportedEncodingException ex) {
throw new RuntimeException(ex);
}
int midPoint = codePoints.length/2;
int firstEnd = midPoint; // exclusive
int secondStart = midPoint+1; // inclusive
int bytesRemoved = utf8Length(codePoints[midPoint]);
// if we have an even number of codepoints, start by removing both middle characters,
// unless just removing the first already removes enough bytes
if (((codePoints.length % 2) == 0) && bytesRemoved < bytesToRemove) {
bytesRemoved += utf8Length(codePoints[secondStart]);
secondStart++;
}
while ((bytesRemoved < bytesToRemove) &&
(firstEnd > 0 || secondStart < codePoints.length)) {
if (firstEnd > 0) {
firstEnd--;
bytesRemoved += utf8Length(codePoints[firstEnd]);
}
if (bytesRemoved < bytesToRemove && secondStart < codePoints.length) {
bytesRemoved += utf8Length(codePoints[secondStart]);
secondStart++;
}
}
StringBuilder sb = new StringBuilder();
for (int i=0; i<firstEnd; i++) {
sb.appendCodePoint(codePoints[i]);
}
sb.append('#');
for (int i=secondStart; i<codePoints.length; i++) {
sb.appendCodePoint(codePoints[i]);
}
return sb.toString();
}
private static boolean isWindows() {
return System.getProperty("os.name").startsWith("Windows");
}
private static Pattern reservedFileNameRegex = Pattern.compile("^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(\\..*)?$",
Pattern.CASE_INSENSITIVE);
private static boolean isReservedFileName(String className) {
return reservedFileNameRegex.matcher(className).matches();
}
private abstract class FileSystemEntry {
@Nullable public final DirectoryEntry parent;
@Nonnull public final String logicalName;
@Nullable protected String physicalName = null;
private FileSystemEntry(@Nullable DirectoryEntry parent, @Nonnull String logicalName) {
this.parent = parent;
this.logicalName = logicalName;
}
@Nonnull public String getNormalizedName(boolean preserveCase) {
String elementName = logicalName;
if (!preserveCase && parent != null && !parent.isCaseSensitive()) {
elementName = elementName.toLowerCase();
}
if (modifyWindowsReservedFilenames && isReservedFileName(elementName)) {
elementName = addSuffixBeforeExtension(elementName, "#");
}
int utf8Length = utf8Length(elementName);
if (utf8Length > getMaxFilenameLength()) {
elementName = shortenPathComponent(elementName, utf8Length - getMaxFilenameLength());
}
return elementName;
}
@Nullable
public String getPhysicalName() {
return physicalName;
}
public void setSuffix(int suffix) {
if (suffix < 0 || suffix > 99999) {
throw new IllegalArgumentException("suffix must be in [0, 100000)");
}
if (this.physicalName != null) {
throw new IllegalStateException("The suffix can only be set once");
}
this.physicalName = makePhysicalName(suffix);
}
protected abstract String makePhysicalName(int suffix);
}
private class DirectoryEntry extends FileSystemEntry {
@Nullable private File file = null;
private int caseSensitivity = forcedCaseSensitivity;
// maps a normalized (but not suffixed) entry name to 1 or more FileSystemEntries.
// Each FileSystemEntry asociated with a normalized entry name must have a distinct
// physical name
private final Multimap<String, FileSystemEntry> children = ArrayListMultimap.create();
public DirectoryEntry(@Nonnull File path) {
super(null, path.getName());
file = path;
physicalName = file.getName();
}
public DirectoryEntry(@Nullable DirectoryEntry parent, @Nonnull String logicalName) {
super(parent, logicalName);
}
public synchronized FileSystemEntry addChild(FileSystemEntry entry) {
String normalizedChildName = entry.getNormalizedName(false);
Collection<FileSystemEntry> entries = children.get(normalizedChildName);
if (entry instanceof DirectoryEntry) {
for (FileSystemEntry childEntry: entries) {
if (childEntry.logicalName.equals(entry.logicalName)) {
return childEntry;
}
}
}
entry.setSuffix(entries.size());
entries.add(entry);
return entry;
}
@Override
protected String makePhysicalName(int suffix) {
if (suffix > 0) {
return getNormalizedName(true) + "." + Integer.toString(suffix);
}
return getNormalizedName(true);
}
@Override
public void setSuffix(int suffix) {
super.setSuffix(suffix);
String physicalName = getPhysicalName();
if (parent != null && physicalName != null) {
file = new File(parent.file, physicalName);
}
}
protected boolean isCaseSensitive() {
if (getPhysicalName() == null || file == null) {
throw new IllegalStateException("Must call setSuffix() first");
}
if (caseSensitivity != NO_VALUE) {
return caseSensitivity == CASE_SENSITIVE;
}
File path = file;
if (path.exists() && path.isFile()) {
if (!path.delete()) {
throw new ExceptionWithContext("Can't delete %s to make it into a directory",
path.getAbsolutePath());
}
}
if (!path.exists() && !path.mkdirs()) {
throw new ExceptionWithContext("Couldn't create directory %s", path.getAbsolutePath());
}
try {
boolean result = testCaseSensitivity(path);
caseSensitivity = result?CASE_SENSITIVE:CASE_INSENSITIVE;
return result;
} catch (IOException ex) {
return false;
}
}
private boolean testCaseSensitivity(File path) throws IOException {
int num = 1;
File f, f2;
do {
f = new File(path, "test." + num);
f2 = new File(path, "TEST." + num++);
} while(f.exists() || f2.exists());
try {
try {
FileWriter writer = new FileWriter(f);
writer.write("test");
writer.flush();
writer.close();
} catch (IOException ex) {
try {f.delete();} catch (Exception ex2) {}
throw ex;
}
if (f2.exists()) {
return false;
}
if (f2.createNewFile()) {
return true;
}
//the above 2 tests should catch almost all cases. But maybe there was a failure while creating f2
//that isn't related to case sensitivity. Let's see if we can open the file we just created using
//f2
try {
CharBuffer buf = CharBuffer.allocate(32);
FileReader reader = new FileReader(f2);
while (reader.read(buf) != -1 && buf.length() < 4);
if (buf.length() == 4 && buf.toString().equals("test")) {
return false;
} else {
//we probably shouldn't get here. If the filesystem was case-sensetive, creating a new
//FileReader should have thrown a FileNotFoundException. Otherwise, we should have opened
//the file and read in the string "test". It's remotely possible that someone else modified
//the file after we created it. Let's be safe and return false here as well
assert(false);
return false;
}
} catch (FileNotFoundException ex) {
return true;
}
} finally {
try { f.delete(); } catch (Exception ex) {}
try { f2.delete(); } catch (Exception ex) {}
}
}
}
private class FileEntry extends FileSystemEntry {
private FileEntry(@Nullable DirectoryEntry parent, @Nonnull String logicalName) {
super(parent, logicalName);
}
@Override
protected String makePhysicalName(int suffix) {
if (suffix > 0) {
return addSuffixBeforeExtension(getNormalizedName(true), '.' + Integer.toString(suffix));
}
return getNormalizedName(true);
}
}
private static String addSuffixBeforeExtension(String pathElement, String suffix) {
int extensionStart = pathElement.lastIndexOf('.');
StringBuilder newName = new StringBuilder(pathElement.length() + suffix.length() + 1);
if (extensionStart < 0) {
newName.append(pathElement);
newName.append(suffix);
} else {
newName.append(pathElement.subSequence(0, extensionStart));
newName.append(suffix);
newName.append(pathElement.subSequence(extensionStart, pathElement.length()));
}
return newName.toString();
}
}