/*
* Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code 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 General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package jdk.internal.jimage.decompressor;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Arrays;
import java.util.List;
import java.util.Properties;
/**
*
* A Decompressor that reconstructs the constant pool of classes.
*
* @implNote This class needs to maintain JDK 8 source compatibility.
*
* It is used internally in the JDK to implement jimage/jrtfs access,
* but also compiled and delivered as part of the jrtfs.jar to support access
* to the jimage file provided by the shipped JDK by tools running on JDK 8.
*/
public class StringSharingDecompressor implements ResourceDecompressor {
public static final int EXTERNALIZED_STRING = 23;
public static final int EXTERNALIZED_STRING_DESCRIPTOR = 25;
private static final int CONSTANT_Utf8 = 1;
private static final int CONSTANT_Integer = 3;
private static final int CONSTANT_Float = 4;
private static final int CONSTANT_Long = 5;
private static final int CONSTANT_Double = 6;
private static final int CONSTANT_Class = 7;
private static final int CONSTANT_String = 8;
private static final int CONSTANT_Fieldref = 9;
private static final int CONSTANT_Methodref = 10;
private static final int CONSTANT_InterfaceMethodref = 11;
private static final int CONSTANT_NameAndType = 12;
private static final int CONSTANT_MethodHandle = 15;
private static final int CONSTANT_MethodType = 16;
private static final int CONSTANT_InvokeDynamic = 18;
private static final int[] SIZES = new int[20];
static {
//SIZES[CONSTANT_Utf8] = XXX;
SIZES[CONSTANT_Integer] = 4;
SIZES[CONSTANT_Float] = 4;
SIZES[CONSTANT_Long] = 8;
SIZES[CONSTANT_Double] = 8;
SIZES[CONSTANT_Class] = 2;
SIZES[CONSTANT_String] = 2;
SIZES[CONSTANT_Fieldref] = 4;
SIZES[CONSTANT_Methodref] = 4;
SIZES[CONSTANT_InterfaceMethodref] = 4;
SIZES[CONSTANT_NameAndType] = 4;
SIZES[CONSTANT_MethodHandle] = 3;
SIZES[CONSTANT_MethodType] = 2;
SIZES[CONSTANT_InvokeDynamic] = 4;
}
public static int[] getSizes() {
return SIZES.clone();
}
@SuppressWarnings("fallthrough")
public static byte[] normalize(StringsProvider provider, byte[] transformed,
int offset) throws IOException {
DataInputStream stream = new DataInputStream(new ByteArrayInputStream(transformed,
offset, transformed.length - offset));
ByteArrayOutputStream outStream = new ByteArrayOutputStream(transformed.length);
DataOutputStream out = new DataOutputStream(outStream);
byte[] header = new byte[8]; //maginc/4, minor/2, major/2
stream.readFully(header);
out.write(header);
int count = stream.readUnsignedShort();
out.writeShort(count);
for (int i = 1; i < count; i++) {
int tag = stream.readUnsignedByte();
byte[] arr;
switch (tag) {
case CONSTANT_Utf8: {
out.write(tag);
String utf = stream.readUTF();
out.writeUTF(utf);
break;
}
case EXTERNALIZED_STRING: {
int index = CompressIndexes.readInt(stream);
String orig = provider.getString(index);
out.write(CONSTANT_Utf8);
out.writeUTF(orig);
break;
}
case EXTERNALIZED_STRING_DESCRIPTOR: {
String orig = reconstruct(provider, stream);
out.write(CONSTANT_Utf8);
out.writeUTF(orig);
break;
}
case CONSTANT_Long:
case CONSTANT_Double: {
i++;
}
default: {
out.write(tag);
int size = SIZES[tag];
arr = new byte[size];
stream.readFully(arr);
out.write(arr);
}
}
}
out.write(transformed, transformed.length - stream.available(),
stream.available());
out.flush();
return outStream.toByteArray();
}
private static String reconstruct(StringsProvider reader, DataInputStream cr)
throws IOException {
int descIndex = CompressIndexes.readInt(cr);
String desc = reader.getString(descIndex);
byte[] encodedDesc = getEncoded(desc);
int indexes_length = CompressIndexes.readInt(cr);
byte[] bytes = new byte[indexes_length];
cr.readFully(bytes);
List<Integer> indices = CompressIndexes.decompressFlow(bytes);
ByteBuffer buffer = ByteBuffer.allocate(encodedDesc.length * 2);
buffer.order(ByteOrder.BIG_ENDIAN);
int argIndex = 0;
for (byte c : encodedDesc) {
if (c == 'L') {
buffer = safeAdd(buffer, c);
int index = indices.get(argIndex);
argIndex += 1;
String pkg = reader.getString(index);
if (pkg.length() > 0) {
pkg = pkg + "/";
byte[] encoded = getEncoded(pkg);
buffer = safeAdd(buffer, encoded);
}
int classIndex = indices.get(argIndex);
argIndex += 1;
String clazz = reader.getString(classIndex);
byte[] encoded = getEncoded(clazz);
buffer = safeAdd(buffer, encoded);
} else {
buffer = safeAdd(buffer, c);
}
}
byte[] encoded = buffer.array();
ByteBuffer result = ByteBuffer.allocate(encoded.length + 2);
result.order(ByteOrder.BIG_ENDIAN);
result.putShort((short) buffer.position());
result.put(encoded, 0, buffer.position());
ByteArrayInputStream stream = new ByteArrayInputStream(result.array());
DataInputStream inStream = new DataInputStream(stream);
String str = inStream.readUTF();
return str;
}
public static byte[] getEncoded(String pre) throws IOException {
ByteArrayOutputStream resultStream = new ByteArrayOutputStream();
DataOutputStream resultOut = new DataOutputStream(resultStream);
resultOut.writeUTF(pre);
byte[] content = resultStream.toByteArray();
// first 2 items are length;
if (content.length <= 2) {
return new byte[0];
}
return Arrays.copyOfRange(content, 2, content.length);
}
private static ByteBuffer safeAdd(ByteBuffer current, byte b) {
byte[] bytes = {b};
return safeAdd(current, bytes);
}
private static ByteBuffer safeAdd(ByteBuffer current, byte[] bytes) {
if (current.remaining() < bytes.length) {
ByteBuffer newBuffer = ByteBuffer.allocate((current.capacity()
+ bytes.length) * 2);
newBuffer.order(ByteOrder.BIG_ENDIAN);
newBuffer.put(current.array(), 0, current.position());
current = newBuffer;
}
current.put(bytes);
return current;
}
@Override
public String getName() {
return StringSharingDecompressorFactory.NAME;
}
public StringSharingDecompressor(Properties properties) {
}
@Override
public byte[] decompress(StringsProvider reader, byte[] content,
int offset, long originalSize) throws Exception {
return normalize(reader, content, offset);
}
}