/*
 * Copyright (c) 2014, 2017, 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;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.IntBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Objects;
import java.util.stream.IntStream;
import jdk.internal.jimage.decompressor.Decompressor;

Implementation Note: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.
/** * @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 BasicImageReader implements AutoCloseable { private static boolean isSystemProperty(String key, String value, String def) { // No lambdas during bootstrap return AccessController.doPrivileged( new PrivilegedAction<Boolean>() { @Override public Boolean run() { return value.equals(System.getProperty(key, def)); } }); } static private final boolean IS_64_BIT = isSystemProperty("sun.arch.data.model", "64", "32"); static private final boolean USE_JVM_MAP = isSystemProperty("jdk.image.use.jvm.map", "true", "true"); static private final boolean MAP_ALL = isSystemProperty("jdk.image.map.all", "true", IS_64_BIT ? "true" : "false"); private final Path imagePath; private final ByteOrder byteOrder; private final String name; private final ByteBuffer memoryMap; private final FileChannel channel; private final ImageHeader header; private final long indexSize; private final IntBuffer redirect; private final IntBuffer offsets; private final ByteBuffer locations; private final ByteBuffer strings; private final ImageStringsReader stringsReader; private final Decompressor decompressor; protected BasicImageReader(Path path, ByteOrder byteOrder) throws IOException { this.imagePath = Objects.requireNonNull(path); this.byteOrder = Objects.requireNonNull(byteOrder); this.name = this.imagePath.toString(); ByteBuffer map; if (USE_JVM_MAP && BasicImageReader.class.getClassLoader() == null) { // Check to see if the jvm has opened the file using libjimage // native entry when loading the image for this runtime map = NativeImageBuffer.getNativeMap(name); } else { map = null; } // Open the file only if no memory map yet or is 32 bit jvm if (map != null && MAP_ALL) { channel = null; } else { channel = FileChannel.open(imagePath, StandardOpenOption.READ); // No lambdas during bootstrap AccessController.doPrivileged(new PrivilegedAction<Void>() { @Override public Void run() { if (BasicImageReader.class.getClassLoader() == null) { try { Class<?> fileChannelImpl = Class.forName("sun.nio.ch.FileChannelImpl"); Method setUninterruptible = fileChannelImpl.getMethod("setUninterruptible"); setUninterruptible.invoke(channel); } catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException | InvocationTargetException ex) { // fall thru - will only happen on JDK-8 systems where this code // is only used by tools using jrt-fs (non-critical.) } } return null; } }); } // If no memory map yet and 64 bit jvm then memory map entire file if (MAP_ALL && map == null) { map = channel.map(FileChannel.MapMode.READ_ONLY, 0, channel.size()); } // Assume we have a memory map to read image file header ByteBuffer headerBuffer = map; int headerSize = ImageHeader.getHeaderSize(); // If no memory map then read header from image file if (headerBuffer == null) { headerBuffer = ByteBuffer.allocateDirect(headerSize); if (channel.read(headerBuffer, 0L) == headerSize) { headerBuffer.rewind(); } else { throw new IOException("\"" + name + "\" is not an image file"); } } else if (headerBuffer.capacity() < headerSize) { throw new IOException("\"" + name + "\" is not an image file"); } // Interpret the image file header header = readHeader(intBuffer(headerBuffer, 0, headerSize)); indexSize = header.getIndexSize(); // If no memory map yet then must be 32 bit jvm not previously mapped if (map == null) { // Just map the image index map = channel.map(FileChannel.MapMode.READ_ONLY, 0, indexSize); } memoryMap = map.asReadOnlyBuffer(); // Interpret the image index if (memoryMap.capacity() < indexSize) { throw new IOException("The image file \"" + name + "\" is corrupted"); } redirect = intBuffer(memoryMap, header.getRedirectOffset(), header.getRedirectSize()); offsets = intBuffer(memoryMap, header.getOffsetsOffset(), header.getOffsetsSize()); locations = slice(memoryMap, header.getLocationsOffset(), header.getLocationsSize()); strings = slice(memoryMap, header.getStringsOffset(), header.getStringsSize()); stringsReader = new ImageStringsReader(this); decompressor = new Decompressor(); } protected BasicImageReader(Path imagePath) throws IOException { this(imagePath, ByteOrder.nativeOrder()); } public static BasicImageReader open(Path imagePath) throws IOException { return new BasicImageReader(imagePath, ByteOrder.nativeOrder()); } public ImageHeader getHeader() { return header; } private ImageHeader readHeader(IntBuffer buffer) throws IOException { ImageHeader result = ImageHeader.readFrom(buffer); if (result.getMagic() != ImageHeader.MAGIC) { throw new IOException("\"" + name + "\" is not an image file"); } if (result.getMajorVersion() != ImageHeader.MAJOR_VERSION || result.getMinorVersion() != ImageHeader.MINOR_VERSION) { throw new IOException("The image file \"" + name + "\" is not " + "the correct version. Major: " + result.getMajorVersion() + ". Minor: " + result.getMinorVersion()); } return result; } private static ByteBuffer slice(ByteBuffer buffer, int position, int capacity) { // Note that this is the only limit and position manipulation of // BasicImageReader private ByteBuffers. The synchronize could be avoided // by cloning the buffer to make a local copy, but at the cost of creating // a new object. synchronized(buffer) { buffer.limit(position + capacity); buffer.position(position); return buffer.slice(); } } private IntBuffer intBuffer(ByteBuffer buffer, int offset, int size) { return slice(buffer, offset, size).order(byteOrder).asIntBuffer(); } public static void releaseByteBuffer(ByteBuffer buffer) { Objects.requireNonNull(buffer); if (!MAP_ALL) { ImageBufferCache.releaseBuffer(buffer); } } public String getName() { return name; } public ByteOrder getByteOrder() { return byteOrder; } public Path getImagePath() { return imagePath; } @Override public void close() throws IOException { if (channel != null) { channel.close(); } } public ImageStringsReader getStrings() { return stringsReader; } public synchronized ImageLocation findLocation(String module, String name) { Objects.requireNonNull(module); Objects.requireNonNull(name); // Details of the algorithm used here can be found in // jdk.tools.jlink.internal.PerfectHashBuilder. int count = header.getTableLength(); int index = redirect.get(ImageStringsReader.hashCode(module, name) % count); if (index < 0) { // index is twos complement of location attributes index. index = -index - 1; } else if (index > 0) { // index is hash seed needed to compute location attributes index. index = ImageStringsReader.hashCode(module, name, index) % count; } else { // No entry. return null; } long[] attributes = getAttributes(offsets.get(index)); if (!ImageLocation.verify(module, name, attributes, stringsReader)) { return null; } return new ImageLocation(attributes, stringsReader); } public synchronized ImageLocation findLocation(String name) { Objects.requireNonNull(name); // Details of the algorithm used here can be found in // jdk.tools.jlink.internal.PerfectHashBuilder. int count = header.getTableLength(); int index = redirect.get(ImageStringsReader.hashCode(name) % count); if (index < 0) { // index is twos complement of location attributes index. index = -index - 1; } else if (index > 0) { // index is hash seed needed to compute location attributes index. index = ImageStringsReader.hashCode(name, index) % count; } else { // No entry. return null; } long[] attributes = getAttributes(offsets.get(index)); if (!ImageLocation.verify(name, attributes, stringsReader)) { return null; } return new ImageLocation(attributes, stringsReader); } public String[] getEntryNames() { int[] attributeOffsets = new int[offsets.capacity()]; offsets.get(attributeOffsets); return IntStream.of(attributeOffsets) .filter(o -> o != 0) .mapToObj(o -> ImageLocation.readFrom(this, o).getFullName()) .sorted() .toArray(String[]::new); } ImageLocation getLocation(int offset) { return ImageLocation.readFrom(this, offset); } public long[] getAttributes(int offset) { if (offset < 0 || offset >= locations.limit()) { throw new IndexOutOfBoundsException("offset"); } ByteBuffer buffer = slice(locations, offset, locations.limit() - offset); return ImageLocation.decompress(buffer); } public String getString(int offset) { if (offset < 0 || offset >= strings.limit()) { throw new IndexOutOfBoundsException("offset"); } ByteBuffer buffer = slice(strings, offset, strings.limit() - offset); return ImageStringsReader.stringFromByteBuffer(buffer); } private byte[] getBufferBytes(ByteBuffer buffer) { Objects.requireNonNull(buffer); byte[] bytes = new byte[buffer.limit()]; buffer.get(bytes); return bytes; } private ByteBuffer readBuffer(long offset, long size) { if (offset < 0 || Integer.MAX_VALUE <= offset) { throw new IndexOutOfBoundsException("Bad offset: " + offset); } if (size < 0 || Integer.MAX_VALUE <= size) { throw new IndexOutOfBoundsException("Bad size: " + size); } if (MAP_ALL) { ByteBuffer buffer = slice(memoryMap, (int)offset, (int)size); buffer.order(ByteOrder.BIG_ENDIAN); return buffer; } else { if (channel == null) { throw new InternalError("Image file channel not open"); } ByteBuffer buffer = ImageBufferCache.getBuffer(size); int read; try { read = channel.read(buffer, offset); buffer.rewind(); } catch (IOException ex) { ImageBufferCache.releaseBuffer(buffer); throw new RuntimeException(ex); } if (read != size) { ImageBufferCache.releaseBuffer(buffer); throw new RuntimeException("Short read: " + read + " instead of " + size + " bytes"); } return buffer; } } public byte[] getResource(String name) { Objects.requireNonNull(name); ImageLocation location = findLocation(name); return location != null ? getResource(location) : null; } public byte[] getResource(ImageLocation loc) { ByteBuffer buffer = getResourceBuffer(loc); if (buffer != null) { byte[] bytes = getBufferBytes(buffer); ImageBufferCache.releaseBuffer(buffer); return bytes; } return null; } public ByteBuffer getResourceBuffer(ImageLocation loc) { Objects.requireNonNull(loc); long offset = loc.getContentOffset() + indexSize; long compressedSize = loc.getCompressedSize(); long uncompressedSize = loc.getUncompressedSize(); if (compressedSize < 0 || Integer.MAX_VALUE < compressedSize) { throw new IndexOutOfBoundsException( "Bad compressed size: " + compressedSize); } if (uncompressedSize < 0 || Integer.MAX_VALUE < uncompressedSize) { throw new IndexOutOfBoundsException( "Bad uncompressed size: " + uncompressedSize); } if (compressedSize == 0) { return readBuffer(offset, uncompressedSize); } else { ByteBuffer buffer = readBuffer(offset, compressedSize); if (buffer != null) { byte[] bytesIn = getBufferBytes(buffer); ImageBufferCache.releaseBuffer(buffer); byte[] bytesOut; try { bytesOut = decompressor.decompressResource(byteOrder, (int strOffset) -> getString(strOffset), bytesIn); } catch (IOException ex) { throw new RuntimeException(ex); } return ByteBuffer.wrap(bytesOut); } } return null; } public InputStream getResourceStream(ImageLocation loc) { Objects.requireNonNull(loc); byte[] bytes = getResource(loc); return new ByteArrayInputStream(bytes); } }