1 /*

     2  * Copyright (c) 2014, 2018, 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.

     8  *

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

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

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

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

    13  * accompanied this code).

    14  *

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

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

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

    18  *

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

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

    21  * questions.

    22  *

    23  */

    24 

    25 #include "precompiled.hpp"

    26 #include "classfile/classLoader.hpp"

    27 #include "classfile/classLoaderExt.hpp"

    28 #include "classfile/dictionary.hpp"

    29 #include "classfile/javaClasses.hpp"

    30 #include "classfile/sharedClassUtil.hpp"

    31 #include "classfile/stringTable.hpp"

    32 #include "classfile/symbolTable.hpp"

    33 #include "classfile/systemDictionary.hpp"

    34 #include "classfile/systemDictionaryShared.hpp"

    35 #include "memory/filemap.hpp"

    36 #include "memory/metadataFactory.hpp"

    37 #include "memory/resourceArea.hpp"

    38 #include "oops/instanceKlass.hpp"

    39 #include "runtime/arguments.hpp"

    40 #include "runtime/java.hpp"

    41 #include "runtime/os.inline.hpp"

    42 

    43 class ManifestStream: public ResourceObj {

    44   private:

    45   u1*   _buffer_start; // Buffer bottom

    46   u1*   _buffer_end;   // Buffer top (one past last element)

    47   u1*   _current;      // Current buffer position

    48 

    49  public:

    50   // Constructor

    51   ManifestStream(u1* buffer, int length) : _buffer_start(buffer),

    52                                            _current(buffer) {

    53     _buffer_end = buffer + length;

    54   }

    55 

    56   static bool is_attr(u1* attr, const char* name) {

    57     return strncmp((const char*)attr, name, strlen(name)) == 0;

    58   }

    59 

    60   static char* copy_attr(u1* value, size_t len) {

    61     char* buf = NEW_RESOURCE_ARRAY(char, len + 1);

    62     strncpy(buf, (char*)value, len);

    63     buf[len] = 0;

    64     return buf;

    65   }

    66 

    67   // The return value indicates if the JAR is signed or not

    68   bool check_is_signed() {

    69     u1* attr = _current;

    70     bool isSigned = false;

    71     while (_current < _buffer_end) {

    72       if (*_current == '\n') {

    73         *_current = '\0';

    74         u1* value = (u1*)strchr((char*)attr, ':');

    75         if (value != NULL) {

    76           assert(*(value+1) == ' ', "Unrecognized format" );

    77           if (strstr((char*)attr, "-Digest") != NULL) {

    78             isSigned = true;

    79             break;

    80           }

    81         }

    82         *_current = '\n'; // restore

    83         attr = _current + 1;

    84       }

    85       _current ++;

    86     }

    87     return isSigned;

    88   }

    89 };

    90 

    91 void SharedPathsMiscInfoExt::print_path(outputStream* out, int type, const char* path) {

    92   switch(type) {

    93   case APP:

    94     ClassLoader::trace_class_path("Expecting -Djava.class.path=", path);

    95     break;

    96   case MODULE:

    97     ClassLoader::trace_class_path("Checking module path: ", path);

    98     break;

    99   default:

   100     SharedPathsMiscInfo::print_path(out, type, path);

   101   }

   102 }

   103 

   104 bool SharedPathsMiscInfoExt::check(jint type, const char* path) {

   105 

   106   switch (type) {

   107   case APP:

   108     {

   109       // Prefix is OK: E.g., dump with -cp foo.jar, but run with -cp foo.jar:bar.jar

   110       size_t len = strlen(path);

   111       const char *appcp = Arguments::get_appclasspath();

   112       assert(appcp != NULL, "NULL app classpath");

   113       size_t appcp_len = strlen(appcp);

   114       if (appcp_len < len) {

   115         return fail("Run time APP classpath is shorter than the one at dump time: ", appcp);

   116       }

   117       ResourceMark rm;

   118       char* tmp_path;

   119       if (len == appcp_len) {

   120         tmp_path = (char*)appcp;

   121       } else {

   122         tmp_path = NEW_RESOURCE_ARRAY(char, len + 1);

   123         strncpy(tmp_path, appcp, len);

   124         tmp_path[len] = 0;

   125       }

   126       if (os::file_name_strcmp(path, tmp_path) != 0) {

   127         return fail("[APP classpath mismatch, actual: -Djava.class.path=", appcp);

   128       }

   129       if (appcp[len] != '\0' && appcp[len] != os::path_separator()[0]) {

   130         return fail("Dump time APP classpath is not a proper prefix of run time APP classpath: ", appcp);

   131       }

   132     }

   133     break;

   134   default:

   135     return SharedPathsMiscInfo::check(type, path);

   136   }

   137 

   138   return true;

   139 }

   140 

   141 void SharedClassUtil::update_shared_classpath(ClassPathEntry *cpe, SharedClassPathEntry* e, TRAPS) {

   142   ClassLoaderData* loader_data = ClassLoaderData::the_null_class_loader_data();

   143   SharedClassPathEntryExt* ent = (SharedClassPathEntryExt*)e;

   144   ResourceMark rm(THREAD);

   145   jint manifest_size;

   146   bool isSigned;

   147 

   148   if (cpe->is_jar_file()) {

   149     char* manifest = ClassLoaderExt::read_manifest(cpe, &manifest_size, CHECK);

   150     if (manifest != NULL) {

   151       ManifestStream* stream = new ManifestStream((u1*)manifest,

   152                                                   manifest_size);

   153       isSigned = stream->check_is_signed();

   154       if (isSigned) {

   155         ent->_is_signed = true;

   156       } else {

   157         // Copy the manifest into the shared archive

   158         manifest = ClassLoaderExt::read_raw_manifest(cpe, &manifest_size, CHECK);

   159         Array<u1>* buf = MetadataFactory::new_array<u1>(loader_data,

   160                                                         manifest_size,

   161                                                         THREAD);

   162         char* p = (char*)(buf->data());

   163         memcpy(p, manifest, manifest_size);

   164         ent->set_manifest(buf);

   165         ent->_is_signed = false;

   166       }

   167     }

   168   }

   169 }

   170 

   171 void SharedClassUtil::initialize(TRAPS) {

   172   if (UseSharedSpaces) {

   173     int size = FileMapInfo::get_number_of_shared_paths();

   174     if (size > 0) {

   175       SystemDictionaryShared::allocate_shared_data_arrays(size, THREAD);

   176       FileMapHeaderExt* header = (FileMapHeaderExt*)FileMapInfo::current_info()->header();

   177       ClassLoaderExt::init_paths_start_index(header->_app_class_paths_start_index);

   178       ClassLoaderExt::init_app_module_paths_start_index(header->_app_module_paths_start_index);

   179     }

   180   }

   181 

   182   if (DumpSharedSpaces) {

   183     if (SharedArchiveConfigFile) {

   184       read_extra_data(SharedArchiveConfigFile, THREAD);

   185     }

   186   }

   187 }

   188 

   189 void SharedClassUtil::read_extra_data(const char* filename, TRAPS) {

   190   HashtableTextDump reader(filename);

   191   reader.check_version("VERSION: 1.0");

   192 

   193   while (reader.remain() > 0) {

   194     int utf8_length;

   195     int prefix_type = reader.scan_prefix(&utf8_length);

   196     ResourceMark rm(THREAD);

   197     char* utf8_buffer = NEW_RESOURCE_ARRAY(char, utf8_length);

   198     reader.get_utf8(utf8_buffer, utf8_length);

   199 

   200     if (prefix_type == HashtableTextDump::SymbolPrefix) {

   201       SymbolTable::new_symbol(utf8_buffer, utf8_length, THREAD);

   202     } else{

   203       assert(prefix_type == HashtableTextDump::StringPrefix, "Sanity");

   204       utf8_buffer[utf8_length] = '\0';

   205       oop s = StringTable::intern(utf8_buffer, THREAD);

   206     }

   207   }

   208 }

   209 

   210 bool SharedClassUtil::is_classpath_entry_signed(int classpath_index) {

   211   assert(classpath_index >= 0, "Sanity");

   212   SharedClassPathEntryExt* ent = (SharedClassPathEntryExt*)

   213     FileMapInfo::shared_path(classpath_index);

   214   return ent->_is_signed;

   215 }

   216 

   217 void FileMapHeaderExt::populate(FileMapInfo* mapinfo, size_t alignment) {

   218   FileMapInfo::FileMapHeader::populate(mapinfo, alignment);

   219 

   220   ClassLoaderExt::finalize_shared_paths_misc_info();

   221   _app_class_paths_start_index = ClassLoaderExt::app_class_paths_start_index();

   222   _app_module_paths_start_index = ClassLoaderExt::app_module_paths_start_index();

   223 

   224   _verify_local = BytecodeVerificationLocal;

   225   _verify_remote = BytecodeVerificationRemote;

   226   _has_platform_or_app_classes = ClassLoaderExt::has_platform_or_app_classes();

   227 }

   228 

   229 bool FileMapHeaderExt::validate() {

   230   if (!FileMapInfo::FileMapHeader::validate()) {

   231     return false;

   232   }

   233 

   234   // This must be done after header validation because it might change the

   235   // header data

   236   const char* prop = Arguments::get_property("java.system.class.loader");

   237   if (prop != NULL) {

   238     warning("Archived non-system classes are disabled because the "

   239             "java.system.class.loader property is specified (value = \"%s\"). "

   240             "To use archived non-system classes, this property must be not be set", prop);

   241     _has_platform_or_app_classes = false;

   242   }

   243 

   244   // For backwards compatibility, we don't check the verification setting

   245   // if the archive only contains system classes.

   246   if (_has_platform_or_app_classes &&

   247       ((!_verify_local && BytecodeVerificationLocal) ||

   248        (!_verify_remote && BytecodeVerificationRemote))) {

   249     FileMapInfo::fail_continue("The shared archive file was created with less restrictive "

   250                   "verification setting than the current setting.");

   251     return false;

   252   }

   253 

   254   return true;

   255 }