1 /*

     2  * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 package jdk.internal.jimage;

    26 

    27 import java.io.IOException;

    28 import java.nio.ByteBuffer;

    29 import java.nio.ByteOrder;

    30 import java.nio.IntBuffer;

    31 import java.nio.MappedByteBuffer;

    32 import java.nio.channels.FileChannel;

    33 import java.util.ArrayList;

    34 import java.util.Arrays;

    35 import java.util.List;

    36 

    37 public class BasicImageReader {

    38     private final String imagePath;

    39     private final PReader preader;

    40     private final ByteOrder byteOrder;

    41     private final ImageHeader header;

    42     private final int indexSize;

    43     private final IntBuffer redirectBuffer;

    44     private final IntBuffer offsetsBuffer;

    45     private final ByteBuffer locationsBuffer;

    46     private final ByteBuffer stringsBuffer;

    47     private final ImageStrings strings;

    48 

    49     protected BasicImageReader(String imagePath, ByteOrder byteOrder) throws IOException {

    50         this.imagePath = imagePath;

    51         this.preader = PReader.open(imagePath);

    52         this.byteOrder = byteOrder;

    53         this.header = ImageHeader.readFrom(byteOrder, getIntBuffer(0, ImageHeader.getHeaderSize()));

    54         this.indexSize = header.getIndexSize();

    55         this.redirectBuffer = getIntBuffer(header.getRedirectOffset(), header.getRedirectSize());

    56         this.offsetsBuffer = getIntBuffer(header.getOffsetsOffset(), header.getOffsetsSize());

    57         this.locationsBuffer = getByteBuffer(header.getLocationsOffset(), header.getLocationsSize());

    58         this.stringsBuffer = getByteBuffer(header.getStringsOffset(), header.getStringsSize());

    59         this.strings = new ImageStrings(new ImageStream(stringsBuffer));

    60     }

    61 

    62     protected BasicImageReader(String imagePath) throws IOException {

    63         this(imagePath, ByteOrder.nativeOrder());

    64     }

    65 

    66     public static BasicImageReader open(String imagePath) throws IOException {

    67         return new BasicImageReader(imagePath, ByteOrder.nativeOrder());

    68     }

    69 

    70     public String imagePath() {

    71         return imagePath;

    72     }

    73 

    74     public boolean isOpen() {

    75         return preader.isOpen();

    76     }

    77 

    78     public void close() throws IOException {

    79         preader.close();

    80     }

    81 

    82     public ImageHeader getHeader() {

    83         return header;

    84     }

    85 

    86     public ImageLocation findLocation(String name) {

    87         return findLocation(new UTF8String(name));

    88     }

    89 

    90     public ImageLocation findLocation(byte[] name) {

    91         return findLocation(new UTF8String(name));

    92     }

    93 

    94     public synchronized ImageLocation findLocation(UTF8String name) {

    95         int count = header.getLocationCount();

    96         int hash = name.hashCode() % count;

    97         int redirect = getRedirect(hash);

    98 

    99         if (redirect == 0) {

   100             return null;

   101         }

   102 

   103         int index;

   104 

   105         if (redirect < 0) {

   106             // If no collision.

   107             index = -redirect - 1;

   108         } else {

   109             // If collision, recompute hash code.

   110             index = name.hashCode(redirect) % count;

   111         }

   112 

   113         int offset = getOffset(index);

   114 

   115         if (offset == 0) {

   116             return null;

   117         }

   118 

   119         ImageLocation location = getLocation(offset);

   120 

   121         return location.verify(name) ? location : null;

   122     }

   123 

   124     public String[] getEntryNames() {

   125         return getEntryNames(true);

   126     }

   127 

   128     public String[] getEntryNames(boolean sorted) {

   129         int count = header.getLocationCount();

   130         List<String> list = new ArrayList<>();

   131 

   132         for (int i = 0; i < count; i++) {

   133             int offset = getOffset(i);

   134 

   135             if (offset != 0) {

   136                 ImageLocation location = ImageLocation.readFrom(locationsBuffer, offset, strings);

   137                 list.add(location.getFullnameString());

   138             }

   139         }

   140 

   141         String[] array = list.toArray(new String[0]);

   142 

   143         if (sorted) {

   144             Arrays.sort(array);

   145         }

   146 

   147         return array;

   148     }

   149 

   150     protected ImageLocation[] getAllLocations(boolean sorted) {

   151         int count = header.getLocationCount();

   152         List<ImageLocation> list = new ArrayList<>();

   153 

   154         for (int i = 0; i < count; i++) {

   155             int offset = getOffset(i);

   156 

   157             if (offset != 0) {

   158                 ImageLocation location = ImageLocation.readFrom(locationsBuffer, offset, strings);

   159                 list.add(location);

   160             }

   161         }

   162 

   163         ImageLocation[] array = list.toArray(new ImageLocation[0]);

   164 

   165         if (sorted) {

   166             Arrays.sort(array, (ImageLocation loc1, ImageLocation loc2) ->

   167                     loc1.getFullnameString().compareTo(loc2.getFullnameString()));

   168         }

   169 

   170         return array;

   171     }

   172 

   173     private IntBuffer getIntBuffer(long offset, long size) throws IOException {

   174         MappedByteBuffer buffer = preader.channel().map(FileChannel.MapMode.READ_ONLY, offset, size);

   175         buffer.order(byteOrder);

   176 

   177         return buffer.asIntBuffer();

   178     }

   179 

   180     private ByteBuffer getByteBuffer(long offset, long size) throws IOException {

   181         MappedByteBuffer buffer = preader.channel().map(FileChannel.MapMode.READ_ONLY, offset, size);

   182         // order is not copied into the readonly copy.

   183         ByteBuffer readOnly = buffer.asReadOnlyBuffer();

   184         readOnly.order(byteOrder);

   185         return readOnly;

   186     }

   187 

   188     private int getRedirect(int index) {

   189         return redirectBuffer.get(index);

   190     }

   191 

   192     private int getOffset(int index) {

   193         return offsetsBuffer.get(index);

   194     }

   195 

   196     private ImageLocation getLocation(int offset) {

   197         return ImageLocation.readFrom(locationsBuffer, offset, strings);

   198     }

   199 

   200     public String getString(int offset) {

   201         return strings.get(offset).toString();

   202     }

   203 

   204     public byte[] getResource(ImageLocation loc) throws IOException {

   205         long compressedSize = loc.getCompressedSize();

   206         assert compressedSize < Integer.MAX_VALUE;

   207 

   208         if (compressedSize == 0) {

   209             return preader.read((int)loc.getUncompressedSize(),

   210                                 indexSize + loc.getContentOffset());

   211         } else {

   212             byte[] buf = preader.read((int)compressedSize,

   213                                       indexSize + loc.getContentOffset());

   214             return ImageFile.Compressor.decompress(buf);

   215         }

   216     }

   217 

   218     public byte[] getResource(String name) throws IOException {

   219         ImageLocation location = findLocation(name);

   220 

   221         return location != null ? getResource(location) : null;

   222     }

   223 

   224     public List<String> getNames(String name) throws IOException {

   225         return getNames(getResource(name));

   226     }

   227 

   228     public List<String> getNames(byte[] bytes) {

   229         IntBuffer buffer = ByteBuffer.wrap(bytes).asIntBuffer();

   230         List<String> names = new ArrayList<>();

   231 

   232         while (buffer.hasRemaining()) {

   233             int offset = buffer.get();

   234             names.add(getString(offset));

   235         }

   236 

   237         return names;

   238     }

   239 }