| /* |
| * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * - 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. |
| * |
| * - Neither the name of Oracle nor the names of its |
| * contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR |
| * CONTRIBUTORS 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. |
| */ |
| |
| #include <assert.h> |
| #include <string.h> |
| #include <stdlib.h> |
| |
| #include "endian.hpp" |
| #include "imageDecompressor.hpp" |
| #include "imageFile.hpp" |
| #include "inttypes.hpp" |
| #include "jni.h" |
| #include "osSupport.hpp" |
| |
| // Map the full jimage, only with 64 bit addressing. |
| bool ImageFileReader::memory_map_image = sizeof(void *) == 8; |
| |
| #ifdef WIN32 |
| const char FileSeparator = '\\'; |
| #else |
| const char FileSeparator = '/'; |
| #endif |
| |
| // Image files are an alternate file format for storing classes and resources. The |
| // goal is to supply file access which is faster and smaller than the jar format. |
| // |
| // (More detailed nodes in the header.) |
| // |
| |
| // Compute the Perfect Hashing hash code for the supplied UTF-8 string. |
| s4 ImageStrings::hash_code(const char* string, s4 seed) { |
| // Access bytes as unsigned. |
| u1* bytes = (u1*)string; |
| // Compute hash code. |
| for (u1 byte = *bytes++; byte; byte = *bytes++) { |
| seed = (seed * HASH_MULTIPLIER) ^ byte; |
| } |
| // Ensure the result is not signed. |
| return seed & 0x7FFFFFFF; |
| } |
| |
| // Match up a string in a perfect hash table. |
| // Returns the index where the name should be. |
| // Result still needs validation for precise match (false positive.) |
| s4 ImageStrings::find(Endian* endian, const char* name, s4* redirect, u4 length) { |
| // If the table is empty, then short cut. |
| if (!redirect || !length) { |
| return NOT_FOUND; |
| } |
| // Compute the basic perfect hash for name. |
| s4 hash_code = ImageStrings::hash_code(name); |
| // Modulo table size. |
| s4 index = hash_code % length; |
| // Get redirect entry. |
| // value == 0 then not found |
| // value < 0 then -1 - value is true index |
| // value > 0 then value is seed for recomputing hash. |
| s4 value = endian->get(redirect[index]); |
| // if recompute is required. |
| if (value > 0 ) { |
| // Entry collision value, need to recompute hash. |
| hash_code = ImageStrings::hash_code(name, value); |
| // Modulo table size. |
| return hash_code % length; |
| } else if (value < 0) { |
| // Compute direct index. |
| return -1 - value; |
| } |
| // No entry found. |
| return NOT_FOUND; |
| } |
| |
| // Test to see if UTF-8 string begins with the start UTF-8 string. If so, |
| // return non-NULL address of remaining portion of string. Otherwise, return |
| // NULL. Used to test sections of a path without copying from image string |
| // table. |
| const char* ImageStrings::starts_with(const char* string, const char* start) { |
| char ch1, ch2; |
| // Match up the strings the best we can. |
| while ((ch1 = *string) && (ch2 = *start)) { |
| if (ch1 != ch2) { |
| // Mismatch, return NULL. |
| return NULL; |
| } |
| // Next characters. |
| string++, start++; |
| } |
| // Return remainder of string. |
| return string; |
| } |
| |
| // Inflates the attribute stream into individual values stored in the long |
| // array _attributes. This allows an attribute value to be quickly accessed by |
| // direct indexing. Unspecified values default to zero (from constructor.) |
| void ImageLocation::set_data(u1* data) { |
| // Deflate the attribute stream into an array of attributes. |
| u1 byte; |
| // Repeat until end header is found. |
| while ((data != NULL) && (byte = *data)) { |
| // Extract kind from header byte. |
| u1 kind = attribute_kind(byte); |
| assert(kind < ATTRIBUTE_COUNT && "invalid image location attribute"); |
| // Extract length of data (in bytes). |
| u1 n = attribute_length(byte); |
| // Read value (most significant first.) |
| _attributes[kind] = attribute_value(data + 1, n); |
| // Position to next attribute by skipping attribute header and data bytes. |
| data += n + 1; |
| } |
| } |
| |
| // Zero all attribute values. |
| void ImageLocation::clear_data() { |
| // Set defaults to zero. |
| memset(_attributes, 0, sizeof(_attributes)); |
| } |
| |
| // ImageModuleData constructor maps out sub-tables for faster access. |
| ImageModuleData::ImageModuleData(const ImageFileReader* image_file) : |
| _image_file(image_file), |
| _endian(image_file->endian()) { |
| } |
| |
| // Release module data resource. |
| ImageModuleData::~ImageModuleData() { |
| } |
| |
| |
| // Return the module in which a package resides. Returns NULL if not found. |
| const char* ImageModuleData::package_to_module(const char* package_name) { |
| // replace all '/' by '.' |
| char* replaced = new char[(int) strlen(package_name) + 1]; |
| assert(replaced != NULL && "allocation failed"); |
| int i; |
| for (i = 0; package_name[i] != '\0'; i++) { |
| replaced[i] = package_name[i] == '/' ? '.' : package_name[i]; |
| } |
| replaced[i] = '\0'; |
| |
| // build path /packages/<package_name> |
| const char* radical = "/packages/"; |
| char* path = new char[(int) strlen(radical) + (int) strlen(package_name) + 1]; |
| assert(path != NULL && "allocation failed"); |
| strcpy(path, radical); |
| strcat(path, replaced); |
| delete[] replaced; |
| |
| // retrieve package location |
| ImageLocation location; |
| bool found = _image_file->find_location(path, location); |
| if (!found) { |
| delete[] path; |
| return NULL; |
| } |
| |
| // retrieve offsets to module name |
| int size = (int)location.get_attribute(ImageLocation::ATTRIBUTE_UNCOMPRESSED); |
| u1* content = new u1[size]; |
| assert(content != NULL && "allocation failed"); |
| _image_file->get_resource(location, content); |
| u1* ptr = content; |
| // sequence of sizeof(8) isEmpty|offset. Use the first module that is not empty. |
| u4 offset = 0; |
| for (i = 0; i < size; i+=8) { |
| u4 isEmpty = _endian->get(*((u4*)ptr)); |
| ptr += 4; |
| if (!isEmpty) { |
| offset = _endian->get(*((u4*)ptr)); |
| break; |
| } |
| ptr += 4; |
| } |
| delete[] content; |
| return _image_file->get_strings().get(offset); |
| } |
| |
| // Manage a table of open image files. This table allows multiple access points |
| // to share an open image. |
| ImageFileReaderTable::ImageFileReaderTable() : _count(0), _max(_growth) { |
| _table = new ImageFileReader*[_max]; |
| assert(_table != NULL && "allocation failed"); |
| } |
| |
| ImageFileReaderTable::~ImageFileReaderTable() { |
| delete[] _table; |
| } |
| |
| // Add a new image entry to the table. |
| void ImageFileReaderTable::add(ImageFileReader* image) { |
| if (_count == _max) { |
| _max += _growth; |
| _table = static_cast<ImageFileReader**>(realloc(_table, _max * sizeof(ImageFileReader*))); |
| } |
| _table[_count++] = image; |
| } |
| |
| // Remove an image entry from the table. |
| void ImageFileReaderTable::remove(ImageFileReader* image) { |
| for (u4 i = 0; i < _count; i++) { |
| if (_table[i] == image) { |
| // Swap the last element into the found slot |
| _table[i] = _table[--_count]; |
| break; |
| } |
| } |
| |
| if (_count != 0 && _count == _max - _growth) { |
| _max -= _growth; |
| _table = static_cast<ImageFileReader**>(realloc(_table, _max * sizeof(ImageFileReader*))); |
| } |
| } |
| |
| // Determine if image entry is in table. |
| bool ImageFileReaderTable::contains(ImageFileReader* image) { |
| for (u4 i = 0; i < _count; i++) { |
| if (_table[i] == image) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| // Table to manage multiple opens of an image file. |
| ImageFileReaderTable ImageFileReader::_reader_table; |
| |
| SimpleCriticalSection _reader_table_lock; |
| |
| // Locate an image if file already open. |
| ImageFileReader* ImageFileReader::find_image(const char* name) { |
| // Lock out _reader_table. |
| SimpleCriticalSectionLock cs(&_reader_table_lock); |
| // Search for an exist image file. |
| for (u4 i = 0; i < _reader_table.count(); i++) { |
| // Retrieve table entry. |
| ImageFileReader* reader = _reader_table.get(i); |
| // If name matches, then reuse (bump up use count.) |
| assert(reader->name() != NULL && "reader->name must not be null"); |
| if (strcmp(reader->name(), name) == 0) { |
| reader->inc_use(); |
| return reader; |
| } |
| } |
| |
| return NULL; |
| } |
| |
| // Open an image file, reuse structure if file already open. |
| ImageFileReader* ImageFileReader::open(const char* name, bool big_endian) { |
| ImageFileReader* reader = find_image(name); |
| if (reader != NULL) { |
| return reader; |
| } |
| |
| // Need a new image reader. |
| reader = new ImageFileReader(name, big_endian); |
| if (reader == NULL || !reader->open()) { |
| // Failed to open. |
| delete reader; |
| return NULL; |
| } |
| |
| // Lock to update |
| SimpleCriticalSectionLock cs(&_reader_table_lock); |
| // Search for an existing image file. |
| for (u4 i = 0; i < _reader_table.count(); i++) { |
| // Retrieve table entry. |
| ImageFileReader* existing_reader = _reader_table.get(i); |
| // If name matches, then reuse (bump up use count.) |
| assert(reader->name() != NULL && "reader->name still must not be null"); |
| if (strcmp(existing_reader->name(), name) == 0) { |
| existing_reader->inc_use(); |
| reader->close(); |
| delete reader; |
| return existing_reader; |
| } |
| } |
| // Bump use count and add to table. |
| reader->inc_use(); |
| _reader_table.add(reader); |
| return reader; |
| } |
| |
| // Close an image file if the file is not in use elsewhere. |
| void ImageFileReader::close(ImageFileReader *reader) { |
| // Lock out _reader_table. |
| SimpleCriticalSectionLock cs(&_reader_table_lock); |
| // If last use then remove from table and then close. |
| if (reader->dec_use()) { |
| _reader_table.remove(reader); |
| delete reader; |
| } |
| } |
| |
| // Return an id for the specifed ImageFileReader. |
| u8 ImageFileReader::reader_to_ID(ImageFileReader *reader) { |
| // ID is just the cloaked reader address. |
| return (u8)reader; |
| } |
| |
| // Validate the image id. |
| bool ImageFileReader::id_check(u8 id) { |
| // Make sure the ID is a managed (_reader_table) reader. |
| SimpleCriticalSectionLock cs(&_reader_table_lock); |
| return _reader_table.contains((ImageFileReader*)id); |
| } |
| |
| // Return an id for the specifed ImageFileReader. |
| ImageFileReader* ImageFileReader::id_to_reader(u8 id) { |
| assert(id_check(id) && "invalid image id"); |
| return (ImageFileReader*)id; |
| } |
| |
| // Constructor intializes to a closed state. |
| ImageFileReader::ImageFileReader(const char* name, bool big_endian) { |
| // Copy the image file name. |
| int len = (int) strlen(name) + 1; |
| _name = new char[len]; |
| assert(_name != NULL && "allocation failed"); |
| strncpy(_name, name, len); |
| // Initialize for a closed file. |
| _fd = -1; |
| _endian = Endian::get_handler(big_endian); |
| _index_data = NULL; |
| } |
| |
| // Close image and free up data structures. |
| ImageFileReader::~ImageFileReader() { |
| // Ensure file is closed. |
| close(); |
| // Free up name. |
| if (_name) { |
| delete[] _name; |
| _name = NULL; |
| } |
| } |
| |
| // Open image file for read access. |
| bool ImageFileReader::open() { |
| // If file exists open for reading. |
| _fd = osSupport::openReadOnly(_name); |
| if (_fd == -1) { |
| return false; |
| } |
| // Retrieve the file size. |
| _file_size = osSupport::size(_name); |
| // Read image file header and verify it has a valid header. |
| size_t header_size = sizeof(ImageHeader); |
| if (_file_size < header_size || |
| !read_at((u1*)&_header, header_size, 0) || |
| _header.magic(_endian) != IMAGE_MAGIC || |
| _header.major_version(_endian) != MAJOR_VERSION || |
| _header.minor_version(_endian) != MINOR_VERSION) { |
| close(); |
| return false; |
| } |
| // Size of image index. |
| _index_size = index_size(); |
| // Make sure file is large enough to contain the index. |
| if (_file_size < _index_size) { |
| return false; |
| } |
| // Memory map image (minimally the index.) |
| _index_data = (u1*)osSupport::map_memory(_fd, _name, 0, (size_t)map_size()); |
| assert(_index_data && "image file not memory mapped"); |
| // Retrieve length of index perfect hash table. |
| u4 length = table_length(); |
| // Compute offset of the perfect hash table redirect table. |
| u4 redirect_table_offset = (u4)header_size; |
| // Compute offset of index attribute offsets. |
| u4 offsets_table_offset = redirect_table_offset + length * (u4)sizeof(s4); |
| // Compute offset of index location attribute data. |
| u4 location_bytes_offset = offsets_table_offset + length * (u4)sizeof(u4); |
| // Compute offset of index string table. |
| u4 string_bytes_offset = location_bytes_offset + locations_size(); |
| // Compute address of the perfect hash table redirect table. |
| _redirect_table = (s4*)(_index_data + redirect_table_offset); |
| // Compute address of index attribute offsets. |
| _offsets_table = (u4*)(_index_data + offsets_table_offset); |
| // Compute address of index location attribute data. |
| _location_bytes = _index_data + location_bytes_offset; |
| // Compute address of index string table. |
| _string_bytes = _index_data + string_bytes_offset; |
| |
| // Initialize the module data |
| module_data = new ImageModuleData(this); |
| // Successful open (if memory allocation succeeded). |
| return module_data != NULL; |
| } |
| |
| // Close image file. |
| void ImageFileReader::close() { |
| // Deallocate the index. |
| if (_index_data) { |
| osSupport::unmap_memory((char*)_index_data, _index_size); |
| _index_data = NULL; |
| } |
| // Close file. |
| if (_fd != -1) { |
| osSupport::close(_fd); |
| _fd = -1; |
| } |
| } |
| |
| // Read directly from the file. |
| bool ImageFileReader::read_at(u1* data, u8 size, u8 offset) const { |
| return (u8)osSupport::read(_fd, (char*)data, size, offset) == size; |
| } |
| |
| // Find the location attributes associated with the path. Returns true if |
| // the location is found, false otherwise. |
| bool ImageFileReader::find_location(const char* path, ImageLocation& location) const { |
| // Locate the entry in the index perfect hash table. |
| s4 index = ImageStrings::find(_endian, path, _redirect_table, table_length()); |
| // If is found. |
| if (index != ImageStrings::NOT_FOUND) { |
| // Get address of first byte of location attribute stream. |
| u1* data = get_location_data(index); |
| // Expand location attributes. |
| location.set_data(data); |
| // Make sure result is not a false positive. |
| return verify_location(location, path); |
| } |
| return false; |
| } |
| |
| // Find the location index and size associated with the path. |
| // Returns the location index and size if the location is found, 0 otherwise. |
| u4 ImageFileReader::find_location_index(const char* path, u8 *size) const { |
| // Locate the entry in the index perfect hash table. |
| s4 index = ImageStrings::find(_endian, path, _redirect_table, table_length()); |
| // If found. |
| if (index != ImageStrings::NOT_FOUND) { |
| // Get address of first byte of location attribute stream. |
| u4 offset = get_location_offset(index); |
| u1* data = get_location_offset_data(offset); |
| // Expand location attributes. |
| ImageLocation location(data); |
| // Make sure result is not a false positive. |
| if (verify_location(location, path)) { |
| *size = (jlong)location.get_attribute(ImageLocation::ATTRIBUTE_UNCOMPRESSED); |
| return offset; |
| } |
| } |
| return 0; // not found |
| } |
| |
| // Assemble the location path from the string fragments indicated in the location attributes. |
| void ImageFileReader::location_path(ImageLocation& location, char* path, size_t max) const { |
| // Manage the image string table. |
| ImageStrings strings(_string_bytes, _header.strings_size(_endian)); |
| // Position to first character of the path buffer. |
| char* next = path; |
| // Temp for string length. |
| size_t length; |
| // Get module string. |
| const char* module = location.get_attribute(ImageLocation::ATTRIBUTE_MODULE, strings); |
| // If module string is not empty string. |
| if (*module != '\0') { |
| // Get length of module name. |
| length = strlen(module); |
| // Make sure there is no buffer overflow. |
| assert(next - path + length + 2 < max && "buffer overflow"); |
| // Append '/module/'. |
| *next++ = '/'; |
| strncpy(next, module, length); next += length; |
| *next++ = '/'; |
| } |
| // Get parent (package) string. |
| const char* parent = location.get_attribute(ImageLocation::ATTRIBUTE_PARENT, strings); |
| // If parent string is not empty string. |
| if (*parent != '\0') { |
| // Get length of module string. |
| length = strlen(parent); |
| // Make sure there is no buffer overflow. |
| assert(next - path + length + 1 < max && "buffer overflow"); |
| // Append 'patent/' . |
| strncpy(next, parent, length); next += length; |
| *next++ = '/'; |
| } |
| // Get base name string. |
| const char* base = location.get_attribute(ImageLocation::ATTRIBUTE_BASE, strings); |
| // Get length of base name. |
| length = strlen(base); |
| // Make sure there is no buffer overflow. |
| assert(next - path + length < max && "buffer overflow"); |
| // Append base name. |
| strncpy(next, base, length); next += length; |
| // Get extension string. |
| const char* extension = location.get_attribute(ImageLocation::ATTRIBUTE_EXTENSION, strings); |
| // If extension string is not empty string. |
| if (*extension != '\0') { |
| // Get length of extension string. |
| length = strlen(extension); |
| // Make sure there is no buffer overflow. |
| assert(next - path + length + 1 < max && "buffer overflow"); |
| // Append '.extension' . |
| *next++ = '.'; |
| strncpy(next, extension, length); next += length; |
| } |
| // Make sure there is no buffer overflow. |
| assert((size_t)(next - path) < max && "buffer overflow"); |
| // Terminate string. |
| *next = '\0'; |
| } |
| |
| // Verify that a found location matches the supplied path (without copying.) |
| bool ImageFileReader::verify_location(ImageLocation& location, const char* path) const { |
| // Manage the image string table. |
| ImageStrings strings(_string_bytes, _header.strings_size(_endian)); |
| // Position to first character of the path string. |
| const char* next = path; |
| // Get module name string. |
| const char* module = location.get_attribute(ImageLocation::ATTRIBUTE_MODULE, strings); |
| // If module string is not empty. |
| if (*module != '\0') { |
| // Compare '/module/' . |
| if (*next++ != '/') return false; |
| if (!(next = ImageStrings::starts_with(next, module))) return false; |
| if (*next++ != '/') return false; |
| } |
| // Get parent (package) string |
| const char* parent = location.get_attribute(ImageLocation::ATTRIBUTE_PARENT, strings); |
| // If parent string is not empty string. |
| if (*parent != '\0') { |
| // Compare 'parent/' . |
| if (!(next = ImageStrings::starts_with(next, parent))) return false; |
| if (*next++ != '/') return false; |
| } |
| // Get base name string. |
| const char* base = location.get_attribute(ImageLocation::ATTRIBUTE_BASE, strings); |
| // Compare with basne name. |
| if (!(next = ImageStrings::starts_with(next, base))) return false; |
| // Get extension string. |
| const char* extension = location.get_attribute(ImageLocation::ATTRIBUTE_EXTENSION, strings); |
| // If extension is not empty. |
| if (*extension != '\0') { |
| // Compare '.extension' . |
| if (*next++ != '.') return false; |
| if (!(next = ImageStrings::starts_with(next, extension))) return false; |
| } |
| // True only if complete match and no more characters. |
| return *next == '\0'; |
| } |
| |
| // Return the resource for the supplied location offset. |
| void ImageFileReader::get_resource(u4 offset, u1* uncompressed_data) const { |
| // Get address of first byte of location attribute stream. |
| u1* data = get_location_offset_data(offset); |
| // Expand location attributes. |
| ImageLocation location(data); |
| // Read the data |
| get_resource(location, uncompressed_data); |
| } |
| |
| // Return the resource for the supplied location. |
| void ImageFileReader::get_resource(ImageLocation& location, u1* uncompressed_data) const { |
| // Retrieve the byte offset and size of the resource. |
| u8 offset = location.get_attribute(ImageLocation::ATTRIBUTE_OFFSET); |
| u8 uncompressed_size = location.get_attribute(ImageLocation::ATTRIBUTE_UNCOMPRESSED); |
| u8 compressed_size = location.get_attribute(ImageLocation::ATTRIBUTE_COMPRESSED); |
| // If the resource is compressed. |
| if (compressed_size != 0) { |
| u1* compressed_data; |
| // If not memory mapped read in bytes. |
| if (!memory_map_image) { |
| // Allocate buffer for compression. |
| compressed_data = new u1[(size_t)compressed_size]; |
| assert(compressed_data != NULL && "allocation failed"); |
| // Read bytes from offset beyond the image index. |
| bool is_read = read_at(compressed_data, compressed_size, _index_size + offset); |
| assert(is_read && "error reading from image or short read"); |
| } else { |
| compressed_data = get_data_address() + offset; |
| } |
| // Get image string table. |
| const ImageStrings strings = get_strings(); |
| // Decompress resource. |
| ImageDecompressor::decompress_resource(compressed_data, uncompressed_data, uncompressed_size, |
| &strings, _endian); |
| // If not memory mapped then release temporary buffer. |
| if (!memory_map_image) { |
| delete[] compressed_data; |
| } |
| } else { |
| // Read bytes from offset beyond the image index. |
| bool is_read = read_at(uncompressed_data, uncompressed_size, _index_size + offset); |
| assert(is_read && "error reading from image or short read"); |
| } |
| } |
| |
| // Return the ImageModuleData for this image |
| ImageModuleData * ImageFileReader::get_image_module_data() { |
| return module_data; |
| } |