src/java.base/share/classes/jdk/internal/jimage/BasicImageReader.java - platform/libcore - Git at Google

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

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

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